docs(changelog): add changelog for 2.2.2

chore(release): cut the 2.2.2 release
fix(build): update versions of umd bundles (#13038 )
2026-09-14 13:54:52 +08:00 · 2016-11-22 14:36:49 -08:00 · 2016-11-22 14:33:08 -08:00 · 2016-11-22 14:26:20 -08:00 · 2016-11-22 14:26:20 -08:00 · 2016-11-22 14:26:20 -08:00
397 changed files with 6495 additions and 20247 deletions
@@ -1,187 +1,3 @@
-<a name="2.4.1"></a>
-## [2.4.1](https://github.com/angular/angular/compare/2.4.0...2.4.1) (2016-12-21)
-
-### Bug Fixes
-
-* **animations:** always quote string map key values in AOT code ([#13602](https://github.com/angular/angular/issues/13602)) ([6a5e46c](https://github.com/angular/angular/commit/6a5e46c))
-* **animations:** always recover from a failed animation step ([#13604](https://github.com/angular/angular/issues/13604)) ([d788c67](https://github.com/angular/angular/commit/d788c67))
-* **compiler:** ignore `@import` in comments ([#13368](https://github.com/angular/angular/issues/13368)) ([6316e5d](https://github.com/angular/angular/commit/6316e5d)), closes [#12196](https://github.com/angular/angular/issues/12196)
-* **core:** improve error message when component factory cannot be found ([#13541](https://github.com/angular/angular/issues/13541)) ([b9e979e](https://github.com/angular/angular/commit/b9e979e)), closes [#12678](https://github.com/angular/angular/issues/12678)
-* **router:** should reset location if a navigation by location is successful ([#13545](https://github.com/angular/angular/issues/13545)) ([a38f14b](https://github.com/angular/angular/commit/a38f14b)), closes [#13491](https://github.com/angular/angular/issues/13491)
-
-
-
-<a name="2.4.0"></a>
-# [2.4.0 stability-interjection](https://github.com/angular/angular/compare/2.3.1...2.4.0) (2016-12-20)
-
-
-### Bug Fixes
-
-* **animations:** allow players to be destroyed before initialized ([#13346](https://github.com/angular/angular/issues/13346)) ([b36f4bc](https://github.com/angular/angular/commit/b36f4bc)), closes [#13293](https://github.com/angular/angular/issues/13293)
-* **build:** use bash string comparison operator ([#13502](https://github.com/angular/angular/issues/13502)) ([50afbe0](https://github.com/angular/angular/commit/50afbe0))
-* **compiler:** do not lex `}}` when interpolation is disabled ([#13531](https://github.com/angular/angular/issues/13531)) ([9b87bb6](https://github.com/angular/angular/commit/9b87bb6)), closes [#13525](https://github.com/angular/angular/issues/13525)
-* **compiler-cli:** produce metadata for .d.ts files without metadata ([#13526](https://github.com/angular/angular/issues/13526)) ([debb0c9](https://github.com/angular/angular/commit/debb0c9)), closes [#13307](https://github.com/angular/angular/issues/13307) [#13473](https://github.com/angular/angular/issues/13473) [#13521](https://github.com/angular/angular/issues/13521)
-* **i18n:** add a default example to xmb placeholders ([#13507](https://github.com/angular/angular/issues/13507)) ([3f17841](https://github.com/angular/angular/commit/3f17841))
-* **upgrade:** fix `registerForNg1Tests` ([#13522](https://github.com/angular/angular/issues/13522)) ([c26c24c](https://github.com/angular/angular/commit/c26c24c))
-
-
-### Features
-
-* update to `rxjs@5.0.1` and unpin the rxjs peerDeps via `^5.0.1` ([#13572](https://github.com/angular/angular/issues/13572)) ([8d5da1e](https://github.com/angular/angular/commit/8d5da1e)), closes [#13561](https://github.com/angular/angular/issues/13561) [#13478](https://github.com/angular/angular/issues/13478)
-
-
-
-<a name="2.3.1"></a>
-## [2.3.1](https://github.com/angular/angular/compare/2.3.0...2.3.1) (2016-12-15)
-
-
-### Bug Fixes
-
-* **animations:** always cleanup players after they have finished internally ([#13334](https://github.com/angular/angular/issues/13334)) ([a26e054](https://github.com/angular/angular/commit/a26e054)), closes [#13333](https://github.com/angular/angular/issues/13333)
-* **animations:** throw errors and normalize offset beyond the range of [0,1] ([6557bc3](https://github.com/angular/angular/commit/6557bc3)), closes [#13348](https://github.com/angular/angular/issues/13348) [#13440](https://github.com/angular/angular/issues/13440)
-* **compiler:** emit quoted object literal keys if the source is quoted ([ecfad46](https://github.com/angular/angular/commit/ecfad46)), closes [#13249](https://github.com/angular/angular/issues/13249) [#13356](https://github.com/angular/angular/issues/13356)
-* **compiler:** fix merge error in compiler_host ([69b52eb](https://github.com/angular/angular/commit/69b52eb))
-* **compiler:** fix PR 13322 ([#13331](https://github.com/angular/angular/issues/13331)) ([79728b4](https://github.com/angular/angular/commit/79728b4))
-* **compiler:** fix simplify a reference without a name ([1c279b3](https://github.com/angular/angular/commit/1c279b3)), closes [#13470](https://github.com/angular/angular/issues/13470)
-* **compiler:** fix transpiled ES5 code ([#13322](https://github.com/angular/angular/issues/13322)) ([6c1d790](https://github.com/angular/angular/commit/6c1d790)), closes [#13301](https://github.com/angular/angular/issues/13301)
-* **compiler:** generated CSS files suffixed with ngstyle. ([#13353](https://github.com/angular/angular/issues/13353)) ([c8a9b70](https://github.com/angular/angular/commit/c8a9b70)), closes [#13141](https://github.com/angular/angular/issues/13141)
-* **compiler:** make sure provider values with `name` property don’t break. ([efa2d80](https://github.com/angular/angular/commit/efa2d80)), closes [#13394](https://github.com/angular/angular/issues/13394) [#13445](https://github.com/angular/angular/issues/13445)
-* **compiler:** narrow the span reported for invalid pipes ([307d305](https://github.com/angular/angular/commit/307d305)), closes [#13326](https://github.com/angular/angular/issues/13326) [#13411](https://github.com/angular/angular/issues/13411)
-* **compiler:** propagate exports when upgrading metadata to v2 ([f6ef7d6](https://github.com/angular/angular/commit/f6ef7d6))
-* **compiler:** resolver should merge host bindings and listeners ([#13474](https://github.com/angular/angular/issues/13474)) ([6aeaca3](https://github.com/angular/angular/commit/6aeaca3)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **compiler:** support dotted property binding ([8db184d](https://github.com/angular/angular/commit/8db184d)), closes [angular/flex-layout#34](https://github.com/angular/flex-layout/issues/34)
-* **compiler:** update to metadata version 3 ([#13464](https://github.com/angular/angular/issues/13464)) ([b9b557c](https://github.com/angular/angular/commit/b9b557c))
-* **core:** detectChanges() doesn't work on detached instance ([4d6ac9d](https://github.com/angular/angular/commit/4d6ac9d)), closes [#13426](https://github.com/angular/angular/issues/13426) [#13472](https://github.com/angular/angular/issues/13472)
-* **core:** properly destroy embedded Views attatched to ApplicationRef ([#13459](https://github.com/angular/angular/issues/13459)) ([d40bbf4](https://github.com/angular/angular/commit/d40bbf4)), closes [#13062](https://github.com/angular/angular/issues/13062)
-* **core:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
-* **forms:** ensure `select[multiple]` retains selections ([b3dcff0](https://github.com/angular/angular/commit/b3dcff0)), closes [#12527](https://github.com/angular/angular/issues/12527) [#12654](https://github.com/angular/angular/issues/12654)
-* **forms:** fix Validators.min/maxLength with FormArray ([#13095](https://github.com/angular/angular/issues/13095)) ([7383e4a](https://github.com/angular/angular/commit/7383e4a)), closes [#13089](https://github.com/angular/angular/issues/13089)
-* **forms:** introduce checkbox required validator ([124267c](https://github.com/angular/angular/commit/124267c)), closes [#11459](https://github.com/angular/angular/issues/11459) [#13364](https://github.com/angular/angular/issues/13364)
-* **http:** check response body text against undefined ([#13017](https://github.com/angular/angular/issues/13017)) ([f106a18](https://github.com/angular/angular/commit/f106a18))
-* **http:** create a copy of headers when merge options ([#13365](https://github.com/angular/angular/issues/13365)) ([65c9b5b](https://github.com/angular/angular/commit/65c9b5b)), closes [#11980](https://github.com/angular/angular/issues/11980)
-* **language-service:** correctly type `undefined` ([0a7364f](https://github.com/angular/angular/commit/0a7364f)), closes [#13412](https://github.com/angular/angular/issues/13412) [#13414](https://github.com/angular/angular/issues/13414)
-* **compiler**: better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
-* **language-service:** treat string unions as strings ([#13406](https://github.com/angular/angular/issues/13406)) ([14dd2b3](https://github.com/angular/angular/commit/14dd2b3)), closes [#13403](https://github.com/angular/angular/issues/13403)
-* **router:** add support for query params with multiple values ([e4d5a5f](https://github.com/angular/angular/commit/e4d5a5f)), closes [#11373](https://github.com/angular/angular/issues/11373)
-* **router:** Use T type in Resolve interface ([#13242](https://github.com/angular/angular/issues/13242)) ([5ee8155](https://github.com/angular/angular/commit/5ee8155))
-* **selector:** SelectorMatcher match elements with :not selector ([#12977](https://github.com/angular/angular/issues/12977)) ([392c9ac](https://github.com/angular/angular/commit/392c9ac))
-* **tsc-wrapped:** generate metadata for exports without module specifier ([cd03c77](https://github.com/angular/angular/commit/cd03c77)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **upgrade:** fix downgrade content projection and injector inheritance ([86c5098](https://github.com/angular/angular/commit/86c5098)), closes [#6629](https://github.com/angular/angular/issues/6629) [#7727](https://github.com/angular/angular/issues/7727) [#8729](https://github.com/angular/angular/issues/8729) [#9643](https://github.com/angular/angular/issues/9643) [#9649](https://github.com/angular/angular/issues/9649) [#12675](https://github.com/angular/angular/issues/12675)
-* **upgrade:** enable Angular 1 unit testing of upgrade module ([2fc0560](https://github.com/angular/angular/commit/2fc0560)), closes [#5462](https://github.com/angular/angular/issues/5462) [#12675](https://github.com/angular/angular/issues/12675)
-
-
-### Performance Improvements
-
-* **animations:** always run the animation queue outside of zones ([e2622ad](https://github.com/angular/angular/commit/e2622ad)), closes [#13440](https://github.com/angular/angular/issues/13440)
-
-### Note ###
-
-Due to regression in the 2.3.0 release that was fixed by [#13464](https://github.com/angular/angular/pull/13464), 
-components that have been compiled using 2.3.0 and published to npm will need to be recompiled and republished.
-
-The >=2.3.1 compiler will issue is the following error if it encounters components compiled with 2.3.0:  
-`Unsupported metadata version 2 for module ${module}. This module should be compiled with a newer version of ngc`.
-
-We are adding more tests to our test suite to catch these kinds of problems before we cut a release.
-
-
-<a name="2.3.0"></a>
-# [2.3.0](https://github.com/angular/angular/compare/2.3.0-rc.0...2.3.0) (2016-12-07)
-
-
-### Bug Fixes
-
-* **common:** make sure the plural category exists ([#13169](https://github.com/angular/angular/issues/13169)) ([82c81cd](https://github.com/angular/angular/commit/82c81cd)), closes [#12379](https://github.com/angular/angular/issues/12379)
-* **compiler:** include the summaries of reexported modules / directives / pipes ([#13196](https://github.com/angular/angular/issues/13196)) ([75d1617](https://github.com/angular/angular/commit/75d1617))
-* **compiler:** serialize any `StaticSymbol` correctly, not matter in which context ([5614c4f](https://github.com/angular/angular/commit/5614c4f))
-* **compiler:** short-circut expressions with an index ([#13263](https://github.com/angular/angular/issues/13263)) ([f31c947](https://github.com/angular/angular/commit/f31c947)), closes [#13254](https://github.com/angular/angular/issues/13254)
-* **core:** display framework version on bootstrapped component ([#13252](https://github.com/angular/angular/issues/13252)) ([16efb13](https://github.com/angular/angular/commit/16efb13))
-* **facade:** cache original format string ([#12764](https://github.com/angular/angular/issues/12764)) ([a132287](https://github.com/angular/angular/commit/a132287))
-* **http:** set the default Accept header ([#12989](https://github.com/angular/angular/issues/12989)) ([986abbe](https://github.com/angular/angular/commit/986abbe)), closes [#6354](https://github.com/angular/angular/issues/6354)
-* **language-service:** avoid throwing for invalid class declarations ([#13257](https://github.com/angular/angular/issues/13257)) ([93556a5](https://github.com/angular/angular/commit/93556a5)), closes [#13253](https://github.com/angular/angular/issues/13253)
-* **language-service:** do not throw for invalid metadata ([#13261](https://github.com/angular/angular/issues/13261)) ([4a09c81](https://github.com/angular/angular/commit/4a09c81)), closes [#13255](https://github.com/angular/angular/issues/13255)
-* **language-service:** remove incompletely used parameter from `createLanguageServiceFromTypescript()` ([#13278](https://github.com/angular/angular/issues/13278)) ([25c2141](https://github.com/angular/angular/commit/25c2141)), closes [#13277](https://github.com/angular/angular/issues/13277)
-* **language-service:** update to use `CompilerHost` from compiler-cli ([#13189](https://github.com/angular/angular/issues/13189)) ([3ff6554](https://github.com/angular/angular/commit/3ff6554))
-* **router:** allow specifying a matcher without specifying a path ([bbb7a39](https://github.com/angular/angular/commit/bbb7a39)), closes [#12972](https://github.com/angular/angular/issues/12972)
-* **router:** fix replaceUrl on RouterLink directives ([349ad75](https://github.com/angular/angular/commit/349ad75))
-* **router:** fix skipLocationChanges on RouterLink directives ([f562cbf](https://github.com/angular/angular/commit/f562cbf)), closes [#13156](https://github.com/angular/angular/issues/13156)
-* **router:** make setUpLocationChangeListener idempotent ([25e5b2f](https://github.com/angular/angular/commit/25e5b2f))
-* **router:** runs guards every time when unsuccessfully navigating to the same url over and over again ([#13209](https://github.com/angular/angular/issues/13209)) ([d46b8de](https://github.com/angular/angular/commit/d46b8de))
-* **router:** throw a better error message when angular 1 is not bootstraped ([c767df0](https://github.com/angular/angular/commit/c767df0))
-* **router:** validate nested routes ([#13224](https://github.com/angular/angular/issues/13224)) ([2893c2c](https://github.com/angular/angular/commit/2893c2c)), closes [#12827](https://github.com/angular/angular/issues/12827)
-* **tsc-wrapped:** have UserError display the actual error ([393c100](https://github.com/angular/angular/commit/393c100))
-
-
-### Features
-
-* **compiler:** read and write `.ngsummary.json` files ([614a35d](https://github.com/angular/angular/commit/614a35d)), closes [#12787](https://github.com/angular/angular/issues/12787)
-
-
-
-<a name="2.3.0-rc.0"></a>
-# [2.3.0-rc.0](https://github.com/angular/angular/compare/2.3.0-beta.0...2.3.0-rc.0) (2016-11-30)
-
-
-### Bug Fixes
-
-* **animations:** blend in all previously transitioned styles into next animation if interrupted ([#13014](https://github.com/angular/angular/issues/13014)) ([ef96763](https://github.com/angular/angular/commit/ef96763)), closes [#13013](https://github.com/angular/angular/issues/13013)
-* **benchmarks:** use sanitized style values ([#12943](https://github.com/angular/angular/issues/12943)) ([fc5ac1e](https://github.com/angular/angular/commit/fc5ac1e))
-* **build:** update versions of umd bundles ([#13038](https://github.com/angular/angular/issues/13038)) ([86ffa88](https://github.com/angular/angular/commit/86ffa88)), closes [#13037](https://github.com/angular/angular/issues/13037)
-* **changelog:** replace beta.1 with beta.0 ([#12961](https://github.com/angular/angular/issues/12961)) ([07a986d](https://github.com/angular/angular/commit/07a986d))
-* **ci:** pin version of npm on CircleCI ([#12954](https://github.com/angular/angular/issues/12954)) ([a3884db](https://github.com/angular/angular/commit/a3884db))
-* **closure:** quote date pattern aliases ([#13012](https://github.com/angular/angular/issues/13012)) ([7dcca30](https://github.com/angular/angular/commit/7dcca30))
-* **common:** update DatePipe to allow closure compilation ([b2b7219](https://github.com/angular/angular/commit/b2b7219))
-* **compiler:** correctly evaluate references to static functions ([#13133](https://github.com/angular/angular/issues/13133)) ([627282d](https://github.com/angular/angular/commit/627282d))
-* **compiler:** fix performance regression caused by 5b0f9e2 ([43c0e9a](https://github.com/angular/angular/commit/43c0e9a)), closes [#13146](https://github.com/angular/angular/issues/13146)
-* **compiler:** fix versions of `@angular/tsc-wrapped` ([bccf0e6](https://github.com/angular/angular/commit/bccf0e6))
-* **compiler-cli:** fix paths in source maps to be relative ([2a3ca7b](https://github.com/angular/angular/commit/2a3ca7b)), closes [#13040](https://github.com/angular/angular/issues/13040)
-* **compiler-cli:** pin the version of `tsc-wrapped` ([966bcba](https://github.com/angular/angular/commit/966bcba))
-* **language-service:** harden against partial normalization of directives ([2975d89](https://github.com/angular/angular/commit/2975d89))
-* **core:** shrinkwrap was out of date with packages. ([e45b7ff](https://github.com/angular/angular/commit/e45b7ff))
-* **language-service:** make link check pass ([7194fc2](https://github.com/angular/angular/commit/7194fc2))
-* **router:** guards restore an incorrect url when used with skipLocationChange ([ad20d7d](https://github.com/angular/angular/commit/ad20d7d)), closes [#12825](https://github.com/angular/angular/issues/12825)
-* **router:** support redirects to named outlets ([602522b](https://github.com/angular/angular/commit/602522b)), closes [#12740](https://github.com/angular/angular/issues/12740) [#9921](https://github.com/angular/angular/issues/9921)
-* **tsc-wrapped:** set correct version number ([897555c](https://github.com/angular/angular/commit/897555c))
-* **tsc-wrapped:** still emit version 1 metadata to allow use of new components in old setups ([bc69c74](https://github.com/angular/angular/commit/bc69c74))
-* **upgrade:** call ng1 lifecycle hooks ([#12875](https://github.com/angular/angular/issues/12875)) ([1ef4696](https://github.com/angular/angular/commit/1ef4696))
-* **version:** take all of version string after patch version ([f275f36](https://github.com/angular/angular/commit/f275f36))
-
-
-### Features
-
-* **core:** update RxJS peer dependency to 5.0.0-rc.4 Please see [this gist](https://gist.github.com/robwormald/19dea0c70a6e01aadced6731aed4f9f7) if you depend on the `cache` operator ([2d6a003](https://github.com/angular/angular/commit/2d6a003)), closes [#13125](https://github.com/angular/angular/issues/13125)
-* **core:** upgrade zone.js to v0.7.1 ([c4bbafc](https://github.com/angular/angular/commit/c4bbafc))
-* **build:** record angular version in the dom ([#13164](https://github.com/angular/angular/issues/13164)) ([e628b66](https://github.com/angular/angular/commit/e628b66))
-* **core:** expose destroy() method on ViewRef ([808275a](https://github.com/angular/angular/commit/808275a))
-* **core:** properly support inheritance ([f5c8e09](https://github.com/angular/angular/commit/f5c8e09)), closes [#11606](https://github.com/angular/angular/issues/11606) [#12892](https://github.com/angular/angular/issues/12892)
-* **language-service:** add services to support editors ([#12987](https://github.com/angular/angular/issues/12987)) ([519a324](https://github.com/angular/angular/commit/519a324))
-* **router:** add support for custom route reuse strategies ([42cf06f](https://github.com/angular/angular/commit/42cf06f))
-* **tools:** allow disabling annotation lowering ([c1a62e2](https://github.com/angular/angular/commit/c1a62e2))
-
-
-
-<a name="2.2.4"></a>
-## [2.2.4](https://github.com/angular/angular/compare/2.2.3...2.2.4) (2016-11-30)
-
-
-### Bug Fixes
-
-* **common:** update DatePipe to allow closure compilation ([eba53fd](https://github.com/angular/angular/commit/eba53fd))
-* **compiler:** fix performance regression caused by 5b0f9e2 ([ee2d6e5](https://github.com/angular/angular/commit/ee2d6e5)), closes [#13146](https://github.com/angular/angular/issues/13146)
-* **compiler-cli:** fix paths in source maps to be relative ([eb173bc](https://github.com/angular/angular/commit/eb173bc)), closes [#13040](https://github.com/angular/angular/issues/13040)
-
-
-
-<a name="2.2.3"></a>
-## [2.2.3](https://github.com/angular/angular/compare/2.2.2...2.2.3) (2016-11-23)
-
-### Bug Fixes
-
-* **compiler:** Revert: fix versions of `@angular/tsc-wrapped` ([015ca47](https://github.com/angular/angular/commit/015ca47))
-* **animations:** Revert: blend in all previously transitioned styles into next animation if interrupted ([c12e56e](https://github.com/angular/angular/commit/c12e56e))
-
-
-
 <a name="2.2.2"></a>
 ## [2.2.2](https://github.com/angular/angular/compare/2.2.1...2.2.2) (2016-11-22)

@@ -223,8 +39,6 @@ We are adding more tests to our test suite to catch these kinds of problems befo

 Note: The 2.3.0-beta.0 release also contains all the changes present in the 2.2.1 release.

-
-
 <a name="2.2.1"></a>
 ## [2.2.1](https://github.com/angular/angular/compare/2.2.0...2.2.1) (2016-11-17)

@@ -1046,7 +860,7 @@ prefix using `animate-` must now be preixed using `bind-animate-`.
 * core:
  - `ApplicationRef.dispose` is deprecated. Destroy the module that was
    created during bootstrap instead by calling `NgModuleRef.destroy`.
-  - `ApplicationRef.registerDisposeListener` is deprecated.
+  - `AplicationRef.registerDisposeListener` is deprecated.
    Use the `ngOnDestroy` lifecycle hook for providers or
    `NgModuleRef.onDestroy` instead.
  - `disposePlatform` is deprecated. Use `destroyPlatform` instead.
@@ -57,7 +57,7 @@ We want to fix all the issues as soon as possible, but before fixing a bug we ne
 - 3rd-party libraries and their versions
 - and most importantly - a use-case that fails

-A minimal reproduce scenario using http://plnkr.co/ allows us to quickly confirm a bug (or point out coding problem) as well as confirm that we are fixing the right problem. If plunker is not a suitable way to demonstrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demonstrating the problem.
+A minimal reproduce scenario using http://plnkr.co/ allows us to quickly confirm a bug (or point out coding problem) as well as confirm that we are fixing the right problem. If plunker is not a suitable way to demostrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demostrating the problem.

 We will be insisting on a minimal reproduce scenario in order to save maintainers time and ultimately be able to fix more bugs. Interestingly, from our experience users often find coding problems themselves while preparing a minimal plunk. We understand that sometimes it might be hard to extract essentials bits of code from a larger code-base but we really need to isolate the problem before we can fix it.

@@ -244,7 +244,7 @@ changes to be accepted, the CLA must be signed. It's a quick process, we promise
 [github]: https://github.com/angular/angular
 [gitter]: https://gitter.im/angular/angular
 [individual-cla]: http://code.google.com/legal/individual-cla-v1.0.html
-[js-style-guide]: https://google.github.io/styleguide/jsguide.html
+[js-style-guide]: https://google.github.io/styleguide/javascriptguide.xml
 [jsfiddle]: http://jsfiddle.net
 [plunker]: http://plnkr.co/edit
 [runnable]: http://runnable.com
@@ -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**:
@@ -135,7 +126,7 @@ $ gulp public-api:update

 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
+## Formatting your source code

 Angular uses [clang-format](http://clang.llvm.org/docs/ClangFormat.html) to format the source code. If the source code
 is not properly formatted, the CI will fail and the PR can not be merged.
@@ -146,24 +137,4 @@ You can automatically format your code by running:
 $ gulp format
 ```

-## Publishing your own personal snapshot build

-You may find that your un-merged change needs some validation from external participants.
-Rather than requiring them to pull your Pull Request and build Angular locally, you can
-publish the `*-builds` snapshots just like our Travis build does.
-
-First time, you need to create the github repositories:
-
-``` shell
-$ export TOKEN=[get one from https://github.com/settings/tokens]
-$ CREATE_REPOS=1 ./scripts/publish/publish-build-artifacts.sh [github username]
-```
-
-For subsequent snapshots, just run
-
-``` shell
-$ ./scripts/publish/publish-build-artifacts.sh [github username]
-```
-
-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.
@@ -24,9 +24,8 @@ with it.
 * `comp: forms`: `@kara`
 * `comp: http`: `@jeffbcross`
 * `comp: i18n`: `@vicb`
-* `comp: language service`: `@chuckjaz`
 * `comp: metadata-extractor`: `@chuckjaz`
-* `comp: router`: `@vicb`
+* `comp: router`: `@vsavkin`
 * `comp: testing`: `@juliemr`
 * `comp: upgrade`: `@mhevery`
 * `comp: web-worker`: `@vicb`
@@ -36,7 +36,7 @@ var CIconfiguration = {
  'iOS7': {unitTest: {target: 'BS', required: true}, e2e: {target: null, required: true}},
  'iOS8': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
  'iOS9': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  'iOS10': {unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
+  'iOS10': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
  'WindowsPhone': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}}
 };

@@ -44,10 +44,10 @@ var customLaunchers = {
  'DartiumWithWebPlatform':
      {base: 'Dartium', flags: ['--enable-experimental-web-platform-features']},
  'ChromeNoSandbox': {base: 'Chrome', flags: ['--no-sandbox']},
-  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '54'},
+  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '52'},
  'SL_CHROMEBETA': {base: 'SauceLabs', browserName: 'chrome', version: 'beta'},
  'SL_CHROMEDEV': {base: 'SauceLabs', browserName: 'chrome', version: 'dev'},
-  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '50'},
+  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '46'},
  'SL_FIREFOXBETA': {base: 'SauceLabs', browserName: 'firefox', version: 'beta'},
  'SL_FIREFOXDEV': {base: 'SauceLabs', browserName: 'firefox', version: 'dev'},
  'SL_SAFARI7': {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.9', version: '7.0'},
@@ -96,7 +96,7 @@ var customLaunchers = {
  'BS_IE10': {
    base: 'BrowserStack',
    browser: 'ie',
-    browser_version: '10.1',
+    browser_version: '10.0',
    os: 'Windows',
    os_version: '8'
  },
@@ -17,7 +17,6 @@ PACKAGES=(core
  upgrade
  router
  compiler-cli
-  language-service
  benchpress)
 BUILD_ALL=true
 BUNDLE=true
@@ -145,11 +144,6 @@ do
    $TSC -p ${SRCDIR}/tsconfig-testing.json
  fi

-  if [[ -e ${SRCDIR}/tsconfig-2015.json ]]; then
-    echo "======      COMPILING ESM: ${TSC} -p ${SRCDIR}/tsconfig-2015.json"
-    ${TSC} -p ${SRCDIR}/tsconfig-2015.json
-  fi
-
  echo "======      TSC 1.8 d.ts compat for ${DESTDIR}   ====="
  # safely strips 'readonly' specifier from d.ts files to make them compatible with tsc 1.8
  if [ "$(uname)" == "Darwin" ]; then
@@ -181,6 +175,7 @@ do
      mv ${UMD_ES5_PATH}.tmp ${UMD_ES5_PATH}
      $UGLIFYJS -c --screw-ie8 --comments -o ${UMD_ES5_MIN_PATH} ${UMD_ES5_PATH}

+
      if [[ -e rollup-testing.config.js ]]; then
        echo "======         Rollup ${PACKAGE} testing"
        ../../../node_modules/.bin/rollup -c rollup-testing.config.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
@@ -56,15 +48,12 @@ module.exports = function(config) {

    exclude: [
      'dist/all/@angular/**/e2e_test/**',
-      'dist/all/@angular/**/*node_only_spec.js',
-      'dist/all/@angular/benchpress/**',
+      'dist/all/@angular/router/**',
      'dist/all/@angular/compiler-cli/**',
      'dist/all/@angular/compiler/test/aot/**',
-      'dist/all/@angular/examples/**/e2e_test/*',
-      'dist/all/@angular/language-service/**',
-      'dist/all/@angular/router/**',
-      'dist/all/@angular/platform-browser/testing/e2e_util.js',
+      'dist/all/@angular/benchpress/**',
      'dist/all/angular1_router.js',
+      'dist/all/@angular/platform-browser/testing/e2e_util.js',
      'dist/examples/**/e2e_test/**',
    ],

@@ -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-beta.12",
    "jpm": "1.1.4",
    "firefox-profile": "0.4.0",
    "selenium-webdriver": "^2.53.3"
@@ -6,7 +6,6 @@
 * found in the LICENSE file at https://angular.io/license
 */

-/* tslint:disable:no-console  */
 import {browser} from 'protractor';

 const assertEventsContainsName = function(events: any[], eventName: string) {
@@ -11,6 +11,9 @@
 * @description
 * Entry point for all public APIs of the common package.
 */
-export * from './src/common';
+export * from './src/location';
+export {NgLocalization} from './src/localization';
+export {CommonModule} from './src/common_module';

-// This file only reexports content of the `src` folder. Keep it that way.
+export {NgClass, NgFor, NgIf, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet} from './src/directives/index';
+export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe} from './src/pipes/index';
@@ -1,20 +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
- */
-
-/**
- * @module
- * @description
- * Entry point for all public APIs of the common package.
- */
-export * from './location/index';
-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} from './pipes/index';
-export {VERSION} from './version';
-export {Version} from '@angular/core';
@@ -89,18 +89,9 @@ export class NgForRow {
@Directive({selector: '[ngFor][ngForOf]'})
 export class NgFor implements DoCheck, OnChanges {
  @Input() ngForOf: any;
-  @Input()
-  set ngForTrackBy(fn: TrackByFn) {
-    if (typeof fn !== 'function') {
-      throw new Error(`trackBy must be a function, but received ${JSON.stringify(fn)}`);
-    }
-    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>,
@@ -128,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);
@@ -23,23 +23,9 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
 */
 export function getPluralCategory(
    value: number, cases: string[], ngLocalization: NgLocalization): string {
-  let key = `=${value}`;
+  const nbCase = `=${value}`;

-  if (cases.indexOf(key) > -1) {
-    return key;
-  }
-
-  key = ngLocalization.getPluralCategory(value);
-
-  if (cases.indexOf(key) > -1) {
-    return key;
-  }
-
-  if (cases.indexOf('other') > -1) {
-    return 'other';
-  }
-
-  throw new Error(`No plural message found for value "${value}"`);
+  return cases.indexOf(nbCase) > -1 ? nbCase : ngLocalization.getPluralCategory(value);
 }

 /**
@@ -0,0 +1,13 @@
+/**
+ * @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 * from './location/platform_location';
+export * from './location/location_strategy';
+export * from './location/hash_location_strategy';
+export * from './location/path_location_strategy';
+export * from './location/location';
@@ -17,8 +17,6 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';


 /**
- * @whatItDoes Use URL hash for storing application location data.
- * @description
 * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
 * {@link Location} service to represent its state in the
 * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)
@@ -29,7 +27,18 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';
 *
 * ### Example
 *
- * {@example common/location/ts/hash_location_component.ts region='LocationComponent'}
+ * ```
+ * import {Component, NgModule} from '@angular/core';
+ * import {
+ *   LocationStrategy,
+ *   HashLocationStrategy
+ * } from '@angular/common';
+ *
+ * @NgModule({
+ *   providers: [{provide: LocationStrategy, useClass: HashLocationStrategy}]
+ * })
+ * class AppModule {}
+ * ```
 *
 * @stable
 */
@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-export * from './platform_location';
-export * from './location_strategy';
-export * from './hash_location_strategy';
-export * from './path_location_strategy';
-export * from './location';
@@ -12,8 +12,7 @@ import {LocationStrategy} from './location_strategy';


 /**
- * @whatItDoes `Location` is a service that applications can use to interact with a browser's URL.
- * @description
+ * `Location` is a service that applications can use to interact with a browser's URL.
 * Depending on which {@link LocationStrategy} is used, `Location` will either persist
 * to the URL's path or the URL's hash segment.
 *
@@ -29,7 +28,19 @@ import {LocationStrategy} from './location_strategy';
 * - `/my/app/user/123/` **is not** normalized
 *
 * ### Example
- * {@example common/location/ts/path_location_component.ts region='LocationComponent'}
+ *
+ * ```
+ * import {Component} from '@angular/core';
+ * import {Location} from '@angular/common';
+ *
+ * @Component({selector: 'app-component'})
+ * class AppCmp {
+ *   constructor(location: Location) {
+ *     location.go('/foo');
+ *   }
+ * }
+ * ```
+ *
 * @stable
 */
@Injectable()
@@ -85,7 +96,7 @@ export class Location {
   * used, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.
   */
  prepareExternalUrl(url: string): string {
-    if (url && url[0] !== '/') {
+    if (url.length > 0 && !url.startsWith('/')) {
      url = '/' + url;
    }
    return this._platformStrategy.prepareExternalUrl(url);
@@ -132,7 +143,7 @@ export class Location {
   * is.
   */
  public static normalizeQueryParams(params: string): string {
-    return params && params[0] !== '?' ? '?' + params : params;
+    return (params.length > 0 && params.substring(0, 1) != '?') ? ('?' + params) : params;
  }

  /**
@@ -164,13 +175,25 @@ export class Location {
  /**
   * If url has a trailing slash, remove it, otherwise return url as is.
   */
-  public static stripTrailingSlash(url: string): string { return url.replace(/\/$/, ''); }
+  public static stripTrailingSlash(url: string): string {
+    if (/\/$/g.test(url)) {
+      url = url.substring(0, url.length - 1);
+    }
+    return url;
+  }
 }

 function _stripBaseHref(baseHref: string, url: string): string {
-  return baseHref && url.startsWith(baseHref) ? url.substring(baseHref.length) : url;
+  if (baseHref.length > 0 && url.startsWith(baseHref)) {
+    return url.substring(baseHref.length);
+  }
+  return url;
 }

 function _stripIndexHtml(url: string): string {
-  return url.replace(/\/index.html$/, '');
+  if (/\/index.html$/g.test(url)) {
+    // '/index.html'.length == 11
+    return url.substring(0, url.length - 11);
+  }
+  return url;
 }
@@ -12,7 +12,7 @@ import {LocationChangeListener} from './platform_location';
 /**
 * `LocationStrategy` is responsible for representing and reading route state
 * from the browser's URL. Angular provides two strategies:
- * {@link HashLocationStrategy} and {@link PathLocationStrategy}.
+ * {@link HashLocationStrategy} and {@link PathLocationStrategy} (default).
 *
 * This is used under the hood of the {@link Location} service.
 *
@@ -17,13 +17,14 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';


 /**
- * @whatItDoes Use URL for storing application location data.
- * @description
 * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
 * {@link Location} service to represent its state in the
 * [path](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax) of the
 * browser's URL.
 *
+ * `PathLocationStrategy` is the default binding for {@link LocationStrategy}
+ * provided in {@link ROUTER_PROVIDERS}.
+ *
 * If you're using `PathLocationStrategy`, you must provide a {@link APP_BASE_HREF}
 * or add a base element to the document. This URL prefix that will be preserved
 * when generating and recognizing URLs.
@@ -36,10 +37,6 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';
 * `location.go('/foo')`, the browser's URL will become
 * `example.com/my/app/foo`.
 *
- * ### Example
- *
- * {@example common/location/ts/path_location_component.ts region='LocationComponent'}
- *
 * @stable
 */
@Injectable()
@@ -6,6 +6,8 @@
 * found in the LICENSE file at https://angular.io/license
 */

-export class GeneratedFile {
-  constructor(public srcFileUrl: string, public genFileUrl: string, public source: string) {}
-}
+/**
+ * @module
+ * @description
+ * This module provides a set of common Pipes.
+ */
@@ -59,7 +59,7 @@ const _observableStrategy = new ObservableStrategy();
 * {@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}
 *
 * It's also possible to use `async` with Observables. The example below binds the `time` Observable
- * to the view. The Observable continuously updates the view with the current time.
+ * to the view. The Observable continuesly updates the view with the current time.
 *
 * {@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}
 *
@@ -7,14 +7,11 @@
 */

 import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
-
+import {DateFormatter} from '../facade/intl';
 import {NumberWrapper, isDate} from '../facade/lang';
-
-import {DateFormatter} from './intl';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';


-
 /**
 * @ngModule CommonModule
 * @whatItDoes Formats a date according to locale rules.
@@ -8,9 +8,9 @@

 import {Inject, LOCALE_ID, Pipe, PipeTransform, Type} from '@angular/core';

+import {NumberFormatStyle, NumberFormatter} from '../facade/intl';
 import {NumberWrapper, isBlank, isPresent} from '../facade/lang';

-import {NumberFormatStyle, NumberFormatter} from './intl';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';

 const _NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
@@ -1,19 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * @module
- * @description
- * Entry point for all public APIs of the common package.
- */
-
-import {Version} from '@angular/core';
-/**
- * @stable
- */
-export const VERSION = new Version('0.0.0-PLACEHOLDER');
@@ -294,16 +294,6 @@ export function main() {
       }));

    describe('track by', () => {
-      it('should throw if trackBy is not a function', async(() => {
-           const template =
-               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="item?.id"></template>`;
-           fixture = createTestComponent(template);
-
-           getComponent().items = [{id: 1}, {id: 2}];
-           expect(() => fixture.detectChanges())
-               .toThrowError(/trackBy must be a function, but received null/);
-         }));
-
      it('should set the context to the component instance', async(() => {
           const template =
               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
@@ -7,10 +7,13 @@
 */

 import {LOCALE_ID} from '@angular/core';
-import {TestBed, inject} from '@angular/core/testing';
+import {TestBed} from '@angular/core/testing';
+import {beforeEach, describe, inject, it} from '@angular/core/testing/testing_internal';
+import {expect} from '@angular/platform-browser/testing/matchers';

 import {NgLocaleLocalization, NgLocalization, getPluralCategory} from '../src/localization';

+
 export function main() {
  describe('l10n', () => {

@@ -138,23 +141,6 @@ export function main() {
        expect(getPluralCategory(5, ['one', 'other', '=5'], l10n)).toEqual('=5');
        expect(getPluralCategory(6, ['one', 'other', '=5'], l10n)).toEqual('other');
      });
-
-      it('should fallback to other when the case is not present', () => {
-        const l10n = new NgLocaleLocalization('ro');
-        expect(getPluralCategory(1, ['one', 'other'], l10n)).toEqual('one');
-        // 2 -> 'few'
-        expect(getPluralCategory(2, ['one', 'other'], l10n)).toEqual('other');
-      });
-
-      describe('errors', () => {
-        it('should report an error when the "other" category is not present', () => {
-          expect(() => {
-            const l10n = new NgLocaleLocalization('ro');
-            // 2 -> 'few'
-            getPluralCategory(2, ['one'], l10n);
-          }).toThrowError('No plural message found for value "2"');
-        });
-      });
    });
  });
 }
@@ -22,7 +22,6 @@
    "../../../node_modules/zone.js/dist/zone.js.d.ts"
  ],
  "angularCompilerOptions": {
-    "annotateForClosureCompiler": true,
    "strictMetadataEmit": true
  }
 }
@@ -5,13 +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
 */
+
 export {AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol} from '@angular/compiler';
 export {CodeGenerator} from './src/codegen';
-export {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter, NodeCompilerHostContext} from './src/compiler_host';
+export {CompilerHost, CompilerHostContext, NodeCompilerHostContext} from './src/compiler_host';
 export {Extractor} from './src/extractor';
+
 export * from '@angular/tsc-wrapped';
-export {VERSION} from './src/version';
-
-
-// TODO(hansl): moving to Angular 4 need to update this API.
-export {NgTools_InternalApi_NG_2 as __NGTOOLS_PRIVATE_API_2} from './src/ngtools_api'
@@ -1,3 +0,0 @@
-:host {
-  background-color: blue;
-}
@@ -1,5 +0,0 @@
-<div>
-  <h1 i18n>hello world</h1>
-  <a [routerLink]="['lazy']">lazy</a>
-  <router-outlet></router-outlet>
-</div>
@@ -1,19 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, ViewEncapsulation} from '@angular/core';
-
-
-@Component({
-  selector: 'app-root',
-  templateUrl: 'app.component.html',
-  styleUrls: ['app.component.css'],
-  encapsulation: ViewEncapsulation.None
-})
-export class AppComponent {
-}
@@ -1,32 +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 {Component, NgModule} from '@angular/core';
-import {BrowserModule} from '@angular/platform-browser';
-import {RouterModule} from '@angular/router';
-
-import {AppComponent} from './app.component';
-
-@Component({selector: 'home-view', template: 'home!'})
-export class HomeView {
-}
-
-
-@NgModule({
-  declarations: [AppComponent, HomeView],
-  imports: [
-    BrowserModule, RouterModule.forRoot([
-      {path: 'lazy', loadChildren: './lazy.module#LazyModule'},
-      {path: 'feature2', loadChildren: 'feature2/feature2.module#Feature2Module'},
-      {path: '', component: HomeView}
-    ])
-  ],
-  bootstrap: [AppComponent]
-})
-export class AppModule {
-}
@@ -1,21 +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 {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([{path: '', component: FeatureComponent}])]
-})
-export class FeatureModule {
-}
@@ -1,24 +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 {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'lazy-feature-comp', template: 'lazy feature!'})
-export class LazyFeatureComponent {
-}
-
-@NgModule({
-  imports: [RouterModule.forChild([
-    {path: '', component: LazyFeatureComponent, pathMatch: 'full'},
-    {path: 'feature', loadChildren: './feature.module#FeatureModule'}
-  ])],
-  declarations: [LazyFeatureComponent]
-})
-export class LazyFeatureModule {
-}
@@ -1,23 +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 {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([
-    {path: '', component: FeatureComponent},
-  ])]
-})
-export default class DefaultModule {
-}
@@ -1,26 +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 {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([
-    {path: '', component: FeatureComponent}, {path: 'd', loadChildren: './default.module'} {
-      path: 'e',
-      loadChildren: 'feature/feature.module#FeatureModule'
-    }
-  ])]
-})
-export class Feature2Module {
-}
@@ -1,27 +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 {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'lazy-comp', template: 'lazy!'})
-export class LazyComponent {
-}
-
-@NgModule({
-  imports: [RouterModule.forChild([
-    {path: '', component: LazyComponent, pathMatch: 'full'},
-    {path: 'feature', loadChildren: './feature/feature.module#FeatureModule'},
-    {path: 'lazy-feature', loadChildren: './feature/lazy-feature.module#LazyFeatureModule'}
-  ])],
-  declarations: [LazyComponent]
-})
-export class LazyModule {
-}
-
-export class SecondModule {}
@@ -1,19 +0,0 @@
-{
-  "angularCompilerOptions": {
-    // For TypeScript 1.8, we have to lay out generated files
-    // in the same source directory with your code.
-    "genDir": ".",
-    "debug": true
-  },
-
-  "compilerOptions": {
-    "target": "es5",
-    "experimentalDecorators": true,
-    "noImplicitAny": true,
-    "moduleResolution": "node",
-    "rootDir": "",
-    "declaration": true,
-    "lib": ["es6", "dom"],
-    "baseUrl": "."
-  }
-}
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE translationbundle [<!ELEMENT translationbundle (translation)*>
+<!ATTLIST translationbundle lang CDATA #REQUIRED>
+<!ELEMENT translation (#PCDATA|ph)*>
+<!ATTLIST translation id CDATA #REQUIRED>
+<!ELEMENT ph EMPTY>
+<!ATTLIST ph name CDATA #REQUIRED>
+]>
+<translationbundle>
+  <translation id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4">käännä teksti</translation>
+  <translation id="65cc4ab3b4c438e07c89be2b677d08369fb62da2">tervetuloa</translation>
+  <translation id="63a85808f03b8181e36a952e0fa38202c2304862">other-3rdP-component</translation>
+</translationbundle>
@@ -11,9 +11,7 @@ import {FormsModule} from '@angular/forms';
 import {ServerModule} from '@angular/platform-server';
 import {MdButtonModule} from '@angular2-material/button';

-// Note: don't refer to third_party_src as we want to test that
-// we can compile components from node_modules!
-import {ThirdpartyModule} from 'third_party/module';
+import {ThirdpartyModule} from '../third_party_src/module';

 import {MultipleComponentsMyComp, NextComp} from './a/multiple_components';
 import {AnimateCmp} from './animate';
@@ -21,7 +19,7 @@ import {BasicComp} from './basic';
 import {ComponentUsingThirdParty} from './comp_using_3rdp';
 import {CompWithAnalyzeEntryComponentsProvider, CompWithEntryComponents} from './entry_components';
 import {CompConsumingEvents, CompUsingPipes, CompWithProviders, CompWithReferences, DirPublishingEvents, ModuleUsingCustomElements} from './features';
-import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomeLibModule, SomePipeInRootModule, SomeService} from './module_fixtures';
+import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomePipeInRootModule, SomeService, someLibModuleWithProviders} from './module_fixtures';
 import {CompWithNgContent, ProjectingComp} from './projection';
 import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, DirectiveForQuery} from './queries';

@@ -54,7 +52,7 @@ import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, Directive
    FormsModule,
    MdButtonModule,
    ModuleUsingCustomElements,
-    SomeLibModule.withProviders(),
+    someLibModuleWithProviders(),
    ThirdpartyModule,
  ],
  providers: [SomeService],
@@ -63,13 +63,17 @@ export function provideValueWithEntryComponents(value: any) {
  entryComponents: [CompUsingLibModuleDirectiveAndPipe],
 })
 export class SomeLibModule {
-  static withProviders() {
-    return {
-      ngModule: SomeLibModule,
-      providers: [
-        ServiceUsingLibModule, provideValueWithEntryComponents(
-                                   [{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
-      ]
-    };
-  }
+}
+
+// TODO(tbosch): Make this a static method in `SomeLibModule` once
+// our static reflector supports it.
+// See https://github.com/angular/angular/issues/10266.
+export function someLibModuleWithProviders(): ModuleWithProviders {
+  return {
+    ngModule: SomeLibModule,
+    providers: [
+      ServiceUsingLibModule,
+      provideValueWithEntryComponents([{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
+    ]
+  };
 }
@@ -34,9 +34,9 @@ const EXPECTED_XMB = `<?xml version="1.0" encoding="UTF-8" ?>
 <!ELEMENT ex (#PCDATA)>
 ]>
 <messagebundle>
-  <msg id="8136548302122759730" desc="desc" meaning="meaning">translate me</msg>
-  <msg id="3492007542396725315">Welcome</msg>
-  <msg id="3772663375917578720">other-3rdP-component</msg>
+  <msg id="63a85808f03b8181e36a952e0fa38202c2304862">other-3rdP-component</msg>
+  <msg id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" desc="desc" meaning="meaning">translate me</msg>
+  <msg id="65cc4ab3b4c438e07c89be2b677d08369fb62da2">Welcome</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>
@@ -79,4 +79,5 @@ describe('template i18n extraction output', () => {
    const xlf = fs.readFileSync(xlfOutput, {encoding: 'utf-8'});
    expect(xlf).toEqual(EXPECTED_XLIFF);
  });
+
 });
@@ -1,215 +0,0 @@
-#!/usr/bin/env node
-/**
- * @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
- */
-/* tslint:disable:no-console  */
-
-// Must be imported first, because angular2 decorators throws on load.
-import 'reflect-metadata';
-
-import * as path from 'path';
-import * as ts from 'typescript';
-import * as assert from 'assert';
-import {tsc} from '@angular/tsc-wrapped/src/tsc';
-import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext, __NGTOOLS_PRIVATE_API_2} from '@angular/compiler-cli';
-
-const glob = require('glob');
-
-/**
- * Main method.
- * Standalone program that executes codegen using the ngtools API and tests that files were
- * properly read and wrote.
- */
-function main() {
-  console.log(`testing ngtools API...`);
-
-  Promise.resolve()
-      .then(() => codeGenTest())
-      .then(() => i18nTest())
-      .then(() => lazyRoutesTest())
-      .then(() => {
-        console.log('All done!');
-        process.exit(0);
-      })
-      .catch((err) => {
-        console.error(err.stack);
-        console.error('Test failed');
-        process.exit(1);
-      });
-}
-
-function codeGenTest() {
-  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 codegen for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .codeGen({
-        basePath,
-        compilerOptions: config.parsed.options, program, host,
-
-        angularCompilerOptions: config.ngOptions,
-
-        // i18n options.
-        i18nFormat: null,
-        i18nFile: null,
-        locale: null,
-
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          return hostContext.readResource(fileName);
-        }
-      })
-      .then(() => {
-        console.log(`>>> codegen done, asserting read and wrote files`);
-
-        // Assert for each file that it has been read and each `ts` has a written file associated.
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.module\.ts$/)) {
-            const factory = fileName.replace(/\.module\.ts$/, '.module.ngfactory.ts');
-            assert(wroteFiles.indexOf(factory) != -1, `Expected file "${factory}" to be written.`);
-          } else 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('Compilation failed');
-        throw e;
-      });
-}
-
-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');
-  const project = path.join(basePath, 'tsconfig-build.json');
-
-  const config = tsc.readConfiguration(project, basePath);
-  const host = ts.createCompilerHost(config.parsed.options, true);
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  const lazyRoutes = __NGTOOLS_PRIVATE_API_2.listLazyRoutes({
-    program,
-    host,
-    angularCompilerOptions: config.ngOptions,
-    entryModule: 'app.module#AppModule'
-  });
-
-  const expectations: {[route: string]: string} = {
-    './lazy.module#LazyModule': 'lazy.module.ts',
-    './feature/feature.module#FeatureModule': 'feature/feature.module.ts',
-    './feature/lazy-feature.module#LazyFeatureModule': 'feature/lazy-feature.module.ts',
-    'feature2/feature2.module#Feature2Module': 'feature2/feature2.module.ts',
-    './default.module': 'feature2/default.module.ts',
-    'feature/feature.module#FeatureModule': 'feature/feature.module.ts'
-  };
-
-  Object.keys(lazyRoutes).forEach((route: string) => {
-    assert(route in expectations, `Found a route that was not expected: "${route}".`);
-    assert(
-        lazyRoutes[route] == path.join(basePath, expectations[route]),
-        `Route "${route}" does not point to the expected absolute path ` +
-            `"${path.join(basePath, expectations[route])}". It points to "${lazyRoutes[route]}"`);
-  });
-
-  // Verify that all expectations were met.
-  assert.deepEqual(
-      Object.keys(lazyRoutes), Object.keys(expectations), `Expected routes listed to be: \n` +
-          `  ${JSON.stringify(Object.keys(expectations))}\n` +
-          `Actual:\n` +
-          `  ${JSON.stringify(Object.keys(lazyRoutes))}\n`);
-}
-
-main();
@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-/**
- * @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
- */
-/* tslint:disable:no-console  */
-
-// Must be imported first, because angular2 decorators throws on load.
-import 'reflect-metadata';
-
-import * as path from 'path';
-import * as ts from 'typescript';
-import * as assert from 'assert';
-import {tsc} from '@angular/tsc-wrapped/src/tsc';
-import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext} from '@angular/compiler-cli';
-
-/**
- * Main method.
- * Standalone program that executes the real codegen and tests that
- * ngsummary.json files are used for libraries.
- */
-function main() {
-  console.log(`testing usage of ngsummary.json files in libraries...`);
-  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);
-    }
-    readResource(s: string): Promise<string> {
-      readFiles.push(path.relative(basePath, s));
-      return super.readResource(s);
-    }
-  }
-
-  const config = tsc.readConfiguration(project, basePath);
-  config.ngOptions.basePath = basePath;
-  // This flag tells ngc do not recompile libraries.
-  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();
-      })
-      .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);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Compilation failed');
-        process.exit(1);
-      });
-}
-
-/**
- * Simple adaption of tsc-wrapped main to just run codegen with a CompilerHostContext
- */
-function codegen(
-    config: {parsed: ts.ParsedCommandLine, ngOptions: AngularCompilerOptions},
-    hostContextFactory: (host: ts.CompilerHost) => CompilerHostContext) {
-  const host = ts.createCompilerHost(config.parsed.options, true);
-
-  // HACK: patch the realpath to solve symlink issue here:
-  // https://github.com/Microsoft/TypeScript/issues/9552
-  // todo(misko): remove once facade symlinks are removed
-  host.realpath = (path) => path;
-
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  return CodeGenerator.create(config.ngOptions, {
-                      } as any, program, host, hostContextFactory(host)).codegen();
-}
-
-function assertSomeFileMatch(fileNames: string[], pattern: RegExp) {
-  assert(
-      fileNames.some(fileName => pattern.test(fileName)),
-      `Expected some read files match ${pattern}`);
-}
-
-function assertNoFileMatch(fileNames: string[], pattern: RegExp) {
-  const matches = fileNames.filter(fileName => pattern.test(fileName));
-  assert(
-      matches.length === 0,
-      `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();
@@ -21,8 +21,6 @@
    "src/module",
    "src/bootstrap",
    "test/all_spec",
-    "test/test_ngtools_api",
-    "test/test_summaries",
    "benchmarks/src/tree/ng2/index_aot.ts",
    "benchmarks/src/tree/ng2_switch/index_aot.ts",
    "benchmarks/src/largetable/ng2/index_aot.ts",
@@ -9,7 +9,7 @@
    "ng-xi18n": "./src/extract_i18n.js"
  },
  "dependencies": {
-    "@angular/tsc-wrapped": "0.5.0",
+    "@angular/tsc-wrapped": "^0.4.0",
    "reflect-metadata": "^0.1.2",
    "minimist": "^1.2.0"
  },
@@ -17,11 +17,12 @@ import {readFileSync} from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';

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

-const GENERATED_META_FILES = /\.json$/;
+const GENERATED_FILES = /\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
+const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;

 const PREAMBLE = `/**
 * @fileoverview This file is generated by the Angular 2 template compiler.
@@ -43,7 +44,7 @@ export class CodeGenerator {
    let root = this.options.basePath;
    for (const eachRootDir of this.options.rootDirs || []) {
      if (this.options.trace) {
-        console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
+        console.log(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
      }
      if (path.relative(eachRootDir, filePath).indexOf('.') !== 0) {
        root = eachRootDir;
@@ -67,11 +68,10 @@ export class CodeGenerator {
            sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)))
        .then(generatedModules => {
          generatedModules.forEach(generatedModule => {
-            const sourceFile = this.program.getSourceFile(generatedModule.srcFileUrl);
-            const emitPath = this.calculateEmitPath(generatedModule.genFileUrl);
-            const source = GENERATED_META_FILES.test(emitPath) ? generatedModule.source :
-                                                                 PREAMBLE + generatedModule.source;
-            this.host.writeFile(emitPath, source, false, () => {}, [sourceFile]);
+            const sourceFile = this.program.getSourceFile(generatedModule.fileUrl);
+            const emitPath = this.calculateEmitPath(generatedModule.moduleUrl);
+            this.host.writeFile(
+                emitPath, PREAMBLE + generatedModule.source, false, () => {}, [sourceFile]);
          });
        });
  }
@@ -82,9 +82,9 @@ export class CodeGenerator {
      ngCompilerHost?: CompilerHost): CodeGenerator {
    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);
+      ngCompilerHost = usePathMapping ?
+          new PathMappedCompilerHost(program, tsCompilerHost, options, compilerHostContext) :
+          new CompilerHost(program, tsCompilerHost, options, compilerHostContext);
    }
    const transFile = cliOptions.i18nFile;
    const locale = cliOptions.locale;
@@ -100,8 +100,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;
+}
@@ -15,57 +15,40 @@ import * as ts from 'typescript';
 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$/;
+const IS_GENERATED = /\.(ngfactory|css(\.shim)?)$/;

-export interface CompilerHostContext extends ts.ModuleResolutionHost {
+export interface CompilerHostContext {
+  fileExists(fileName: string): boolean;
+  directoryExists(directoryName: string): boolean;
+  readFile(fileName: string): string;
  readResource(fileName: string): Promise<string>;
  assumeFileExists(fileName: string): void;
 }

 export class CompilerHost implements AotCompilerHost {
  protected metadataCollector = new MetadataCollector();
+  protected context: CompilerHostContext;
  private isGenDirChildOfRootDir: boolean;
  protected basePath: string;
  private genDir: string;
  private resolverCache = new Map<string, ModuleMetadata[]>();
-  protected resolveModuleNameHost: CompilerHostContext;

  constructor(
-      protected program: ts.Program, protected options: AngularCompilerOptions,
-      protected context: CompilerHostContext) {
+      protected program: ts.Program, protected compilerHost: ts.CompilerHost,
+      protected options: AngularCompilerOptions, context?: CompilerHostContext) {
    // normalize the path so that it never ends with '/'.
    this.basePath = path.normalize(path.join(this.options.basePath, '.')).replace(/\\/g, '/');
    this.genDir = path.normalize(path.join(this.options.genDir, '.')).replace(/\\/g, '/');

+    this.context = context || new NodeCompilerHostContext(compilerHost);
    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 +58,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;
  };
@@ -99,7 +81,7 @@ export class CompilerHost implements AotCompilerHost {
  fileNameToModuleName(importedFile: string, containingFile: string): string {
    // If a file does not yet exist (because we compile it later), we still need to
    // assume it exists it so that the `resolve` method works!
-    if (!this.context.fileExists(importedFile)) {
+    if (!this.compilerHost.fileExists(importedFile)) {
      this.context.assumeFileExists(importedFile);
    }

@@ -181,12 +163,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 +178,32 @@ 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);
-      if (!v3Metadata && v1Metadata) {
-        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
+      const v1Metadata = metadatas.find(m => m['version'] === 1);
+      let v2Metadata = metadatas.find(m => m['version'] === 2);
+      if (!v2Metadata && v1Metadata) {
+        // patch up v1 to v2 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
+        v2Metadata = {'__symbolic': 'module', 'version': 2, 'metadata': {}};
+        if (v1Metadata.exports) {
+          v2Metadata.exports = v1Metadata.exports;
+        }
+        for (let prop in v1Metadata.metadata) {
+          v2Metadata.metadata[prop] = v1Metadata.metadata[prop];
+        }
+        const sourceText = this.context.readFile(dtsFilePath);
+        const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
+        if (exports) {
+          for (let prop in exports.metadata) {
+            if (!v2Metadata.metadata[prop]) {
+              v2Metadata.metadata[prop] = exports.metadata[prop];
+            }
+          }
+        }
+        metadatas.push(v2Metadata);
      }
      this.resolverCache.set(filePath, metadatas);
      return metadatas;
@@ -218,89 +213,18 @@ 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);
-    }
-  }
-
-  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 {
-  protected assumedExists: {[fileName: string]: boolean} = {};
+export class NodeCompilerHostContext implements CompilerHostContext {
+  constructor(private host: ts.CompilerHost) {}

-  assumeFileExists(fileName: string): void { this.assumedExists[fileName] = true; }
-}
-
-export class ModuleResolutionHostAdapter extends CompilerHostContextAdapter implements
-    CompilerHostContext {
-  public directoryExists: ((directoryName: string) => boolean)|undefined;
-
-  constructor(private host: ts.ModuleResolutionHost) {
-    super();
-    if (host.directoryExists) {
-      this.directoryExists = (directoryName: string) => host.directoryExists(directoryName);
-    }
-  }
+  private assumedExists: {[fileName: string]: boolean} = {};

  fileExists(fileName: string): boolean {
    return this.assumedExists[fileName] || this.host.fileExists(fileName);
  }

-  readFile(fileName: string): string { return this.host.readFile(fileName); }
-
-  readResource(s: string) {
-    if (!this.host.fileExists(s)) {
-      // TODO: We should really have a test for error cases like this!
-      throw new Error(`Compilation failed. Resource file not found: ${s}`);
-    }
-    return Promise.resolve(this.host.readFile(s));
-  }
-}
-
-export class NodeCompilerHostContext extends CompilerHostContextAdapter implements
-    CompilerHostContext {
-  fileExists(fileName: string): boolean {
-    return this.assumedExists[fileName] || fs.existsSync(fileName);
-  }
-
  directoryExists(directoryName: string): boolean {
    try {
      return fs.statSync(directoryName).isDirectory();
@@ -312,10 +236,12 @@ export class NodeCompilerHostContext extends CompilerHostContextAdapter implemen
  readFile(fileName: string): string { return fs.readFileSync(fileName, 'utf8'); }

  readResource(s: string) {
-    if (!this.fileExists(s)) {
+    if (!this.host.fileExists(s)) {
      // TODO: We should really have a test for error cases like this!
      throw new Error(`Compilation failed. Resource file not found: ${s}`);
    }
-    return Promise.resolve(this.readFile(s));
+    return Promise.resolve(this.host.readFile(s));
  }
+
+  assumeFileExists(fileName: string): void { this.assumedExists[fileName] = true; }
 }
@@ -14,15 +14,42 @@
 // 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:
+        const htmlParser = new compiler.I18NHtmlParser(new compiler.HtmlParser());
+        ext = 'xlf';
+        serializer = new compiler.Xliff(htmlParser, compiler.DEFAULT_INTERPOLATION_CONFIG);
+        break;
+    }
+
+    const dstPath = path.join(ngOptions.genDir, `messages.${ext}`);
+    host.writeFile(dstPath, messageBundle.write(serializer), false);
+  });
 }

 // Entry point
@@ -15,74 +15,27 @@ 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} 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,
+      tsCompilerHost: ts.CompilerHost, ngCompilerHost?: CompilerHost): Extractor {
+    if (!ngCompilerHost) ngCompilerHost = new CompilerHost(program, tsCompilerHost, options);
+    const {extractor: ngExtractor} = compiler.Extractor.create(
+        ngCompilerHost, {excludeFilePattern: excludeFilePattern(options)});
+    return new Extractor(ngExtractor, ngCompilerHost, program);
  }
 }
@@ -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(
@@ -23,25 +22,14 @@ function codegen(
  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen();
 }

-export function main(
-    args: any, consoleError: (s: string) => void = console.error): Promise<number> {
-  const project = args.p || args.project || '.';
-  const cliOptions = new tsc.NgcCliOptions(args);
-
-  return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
-    if (e instanceof tsc.UserError || e instanceof SyntaxError) {
-      consoleError(e.message);
-      return Promise.resolve(1);
-    } else {
-      consoleError(e.stack);
-      consoleError('Compilation failed');
-      return Promise.resolve(1);
-    }
-  });
-}
-
 // CLI entry point
 if (require.main === module) {
  const args = require('minimist')(process.argv.slice(2));
-  main(args).then((exitCode: number) => process.exit(exitCode));
+  const project = args.p || args.project || '.';
+  const cliOptions = new tsc.NgcCliOptions(args);
+  tsc.main(project, cliOptions, codegen).then(exitCode => process.exit(exitCode)).catch(e => {
+    console.error(e.stack);
+    console.error('Compilation failed');
+    process.exit(1);
+  });
 }
@@ -1,150 +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
- */
-
-/**
- * This is a private API for the ngtools toolkit.
- *
- * This API should be stable for NG 2. It can be removed in NG 4..., but should be replaced by
- * something else.
- */
-
-import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
-import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
-import * as ts from 'typescript';
-
-import {CodeGenerator} from './codegen';
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {Extractor} from './extractor';
-import {listLazyRoutesOfModule} from './ngtools_impl';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-
-export interface NgTools_InternalApi_NG2_CodeGen_Options {
-  basePath: string;
-  compilerOptions: ts.CompilerOptions;
-  program: ts.Program;
-  host: ts.CompilerHost;
-
-  angularCompilerOptions: AngularCompilerOptions;
-
-  // i18n options.
-  i18nFormat: string;
-  i18nFile: string;
-  locale: string;
-
-  readResource: (fileName: string) => Promise<string>;
-
-  // Every new property under this line should be optional.
-}
-
-export interface NgTools_InternalApi_NG2_ListLazyRoutes_Options {
-  program: ts.Program;
-  host: ts.CompilerHost;
-  angularCompilerOptions: AngularCompilerOptions;
-  entryModule: string;
-
-  // 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
- * passed in the interface.
- */
-class CustomLoaderModuleResolutionHostAdapter extends ModuleResolutionHostAdapter {
-  constructor(
-      private _readResource: (path: string) => Promise<string>, host: ts.ModuleResolutionHost) {
-    super(host);
-  }
-
-  readResource(path: string) { return this._readResource(path); }
-}
-
-
-/**
- * @internal
- * @private
- */
-export class NgTools_InternalApi_NG_2 {
-  /**
-   * @internal
-   * @private
-   */
-  static codeGen(options: NgTools_InternalApi_NG2_CodeGen_Options): Promise<void> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-    const cliOptions: NgcCliOptions = {
-      i18nFormat: options.i18nFormat,
-      i18nFile: options.i18nFile,
-      locale: options.locale,
-      basePath: options.basePath
-    };
-
-    // Create the Code Generator.
-    const codeGenerator = CodeGenerator.create(
-        options.angularCompilerOptions, cliOptions, options.program, options.host, hostContext);
-
-    return codeGenerator.codegen();
-  }
-
-  /**
-   * @internal
-   * @private
-   */
-  static listLazyRoutes(options: NgTools_InternalApi_NG2_ListLazyRoutes_Options):
-      NgTools_InternalApi_NG_2_LazyRouteMap {
-    const angularCompilerOptions = options.angularCompilerOptions;
-    const program = options.program;
-
-    const moduleResolutionHost = new ModuleResolutionHostAdapter(options.host);
-    const usePathMapping =
-        !!angularCompilerOptions.rootDirs && angularCompilerOptions.rootDirs.length > 0;
-    const ngCompilerHost: AotCompilerHost = usePathMapping ?
-        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 routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
-
-    return Object.keys(routeMap).reduce(
-        (acc: NgTools_InternalApi_NG_2_LazyRouteMap, route: string) => {
-          acc[route] = routeMap[route].absoluteFilePath;
-          return acc;
-        },
-        {});
-  }
-
-  /**
-   * @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);
-  }
-}
@@ -1,205 +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
- */
-
-/**
- * This is a private API for the ngtools toolkit.
- *
- * This API should be stable for NG 2. It can be removed in NG 4..., but should be replaced by
- * something else.
- */
-import {AotCompilerHost, StaticReflector, StaticSymbol} from '@angular/compiler';
-import {NgModule} from '@angular/core';
-
-
-
-// We cannot depend directly to @angular/router.
-type Route = any;
-const ROUTER_MODULE_PATH = '@angular/router/src/router_config_loader';
-const ROUTER_ROUTES_SYMBOL_NAME = 'ROUTES';
-
-
-// LazyRoute information between the extractors.
-export interface LazyRoute {
-  routeDef: RouteDef;
-  absoluteFilePath: string;
-}
-export type LazyRouteMap = {
-  [route: string]: LazyRoute
-};
-
-// A route definition. Normally the short form 'path/to/module#ModuleClassName' is used by
-// the user, and this is a helper class to extract information from it.
-export class RouteDef {
-  private constructor(public readonly path: string, public readonly className: string = null) {}
-
-  toString() {
-    return (this.className === null || this.className == 'default') ?
-        this.path :
-        `${this.path}#${this.className}`;
-  }
-
-  static fromString(entry: string): RouteDef {
-    const split = entry.split('#');
-    return new RouteDef(split[0], split[1] || null);
-  }
-}
-
-
-/**
- *
- * @returns {LazyRouteMap}
- * @private
- */
-export function listLazyRoutesOfModule(
-    entryModule: string, host: AotCompilerHost, reflector: StaticReflector): LazyRouteMap {
-  const entryRouteDef = RouteDef.fromString(entryModule);
-  const containingFile = _resolveModule(entryRouteDef.path, entryRouteDef.path, host);
-  const modulePath = `./${containingFile.replace(/^(.*)\//, '')}`;
-  const className = entryRouteDef.className;
-
-  // List loadChildren of this single module.
-  const staticSymbol = reflector.findDeclaration(modulePath, className, containingFile);
-  const ROUTES = reflector.findDeclaration(ROUTER_MODULE_PATH, ROUTER_ROUTES_SYMBOL_NAME);
-  const lazyRoutes: LazyRoute[] =
-      _extractLazyRoutesFromStaticModule(staticSymbol, reflector, host, ROUTES);
-  const routes: LazyRouteMap = {};
-
-  lazyRoutes.forEach((lazyRoute: LazyRoute) => {
-    const route: string = lazyRoute.routeDef.toString();
-    _assertRoute(routes, lazyRoute);
-    routes[route] = lazyRoute;
-
-    const lazyModuleSymbol = reflector.findDeclaration(
-        lazyRoute.absoluteFilePath, lazyRoute.routeDef.className || 'default');
-    const subRoutes = _extractLazyRoutesFromStaticModule(lazyModuleSymbol, reflector, host, ROUTES);
-
-    // Populate the map using the routes we just found.
-    subRoutes.forEach(subRoute => {
-      _assertRoute(routes, subRoute);
-      routes[subRoute.routeDef.toString()] = subRoute;
-    });
-  });
-
-  return routes;
-}
-
-
-/**
- * Try to resolve a module, and returns its absolute path.
- * @private
- */
-function _resolveModule(modulePath: string, containingFile: string, host: AotCompilerHost) {
-  const result = host.moduleNameToFileName(modulePath, containingFile);
-  if (!result) {
-    throw new Error(`Could not resolve "${modulePath}" from "${containingFile}".`);
-  }
-  return result;
-}
-
-
-/**
- * Throw an exception if a route is in a route map, but does not point to the same module.
- * @private
- */
-function _assertRoute(map: LazyRouteMap, route: LazyRoute) {
-  const r = route.routeDef.toString();
-  if (map[r] && map[r].absoluteFilePath != route.absoluteFilePath) {
-    throw new Error(
-        `Duplicated path in loadChildren detected: "${r}" is used in 2 loadChildren, ` +
-        `but they point to different modules "(${map[r].absoluteFilePath} and ` +
-        `"${route.absoluteFilePath}"). Webpack cannot distinguish on context and would fail to ` +
-        'load the proper one.');
-  }
-}
-
-
-/**
- * Extract all the LazyRoutes from a module. This extracts all `loadChildren` keys from this
- * module and all statically referred modules.
- * @private
- */
-function _extractLazyRoutesFromStaticModule(
-    staticSymbol: StaticSymbol, reflector: StaticReflector, host: AotCompilerHost,
-    ROUTES: StaticSymbol): LazyRoute[] {
-  const moduleMetadata = _getNgModuleMetadata(staticSymbol, reflector);
-  const allRoutes: any =
-      (moduleMetadata.imports || [])
-          .filter(i => 'providers' in i)
-          .reduce((mem: Route[], m: any) => {
-            return mem.concat(_collectRoutes(m.providers || [], reflector, ROUTES));
-          }, _collectRoutes(moduleMetadata.providers || [], reflector, ROUTES));
-
-  const lazyRoutes: LazyRoute[] =
-      _collectLoadChildren(allRoutes).reduce((acc: LazyRoute[], route: string) => {
-        const routeDef = RouteDef.fromString(route);
-        const absoluteFilePath = _resolveModule(routeDef.path, staticSymbol.filePath, host);
-        acc.push({routeDef, absoluteFilePath});
-        return acc;
-      }, []);
-
-  const importedSymbols = ((moduleMetadata.imports || []) as any[])
-                              .filter(i => i instanceof StaticSymbol) as StaticSymbol[];
-
-  return importedSymbols
-      .reduce(
-          (acc: LazyRoute[], i: StaticSymbol) => {
-            return acc.concat(_extractLazyRoutesFromStaticModule(i, reflector, host, ROUTES));
-          },
-          [])
-      .concat(lazyRoutes);
-}
-
-
-/**
- * Get the NgModule Metadata of a symbol.
- * @private
- */
-function _getNgModuleMetadata(staticSymbol: StaticSymbol, reflector: StaticReflector): NgModule {
-  const ngModules = reflector.annotations(staticSymbol).filter((s: any) => s instanceof NgModule);
-  if (ngModules.length === 0) {
-    throw new Error(`${staticSymbol.name} is not an NgModule`);
-  }
-  return ngModules[0];
-}
-
-
-/**
- * Return the routes from the provider list.
- * @private
- */
-function _collectRoutes(
-    providers: any[], reflector: StaticReflector, ROUTES: StaticSymbol): Route[] {
-  return providers.reduce((routeList: Route[], p: any) => {
-    if (p.provide === ROUTES) {
-      return routeList.concat(p.useValue);
-    } else if (Array.isArray(p)) {
-      return routeList.concat(_collectRoutes(p, reflector, ROUTES));
-    } else {
-      return routeList;
-    }
-  }, []);
-}
-
-
-/**
- * Return the loadChildren values of a list of Route.
- * @private
- */
-function _collectLoadChildren(routes: Route[]): string[] {
-  return routes.reduce((m, r) => {
-    if (r.loadChildren) {
-      return m.concat(r.loadChildren);
-    } else if (Array.isArray(r)) {
-      return m.concat(_collectLoadChildren(r));
-    } else if (r.children) {
-      return m.concat(_collectLoadChildren(r.children));
-    } else {
-      return m;
-    }
-  }, []);
-}
@@ -25,8 +25,10 @@ const DTS = /\.d\.ts$/;
 * loader what to do.
 */
 export class PathMappedCompilerHost extends CompilerHost {
-  constructor(program: ts.Program, options: AngularCompilerOptions, context: CompilerHostContext) {
-    super(program, options, context);
+  constructor(
+      program: ts.Program, compilerHost: ts.CompilerHost, options: AngularCompilerOptions,
+      context?: CompilerHostContext) {
+    super(program, compilerHost, options, context);
  }

  getCanonicalFileName(fileName: string): string {
@@ -54,7 +56,7 @@ export class PathMappedCompilerHost extends CompilerHost {
          ts.resolveModuleName(m, rootedContainingFile, this.options, this.context).resolvedModule;
      if (resolved) {
        if (this.options.traceResolution) {
-          console.error('resolve', m, containingFile, '=>', resolved.resolvedFileName);
+          console.log('resolve', m, containingFile, '=>', resolved.resolvedFileName);
        }
        return this.getCanonicalFileName(resolved.resolvedFileName);
      }
@@ -69,7 +71,7 @@ export class PathMappedCompilerHost extends CompilerHost {
   */
  fileNameToModuleName(importedFile: string, containingFile: string): string {
    if (this.options.traceResolution) {
-      console.error(
+      console.log(
          'getImportPath from containingFile', containingFile, 'to importedFile', importedFile);
    }

@@ -117,7 +119,7 @@ export class PathMappedCompilerHost extends CompilerHost {
  getMetadataFor(filePath: string): ModuleMetadata[] {
    for (const root of this.options.rootDirs || []) {
      const rootedPath = path.join(root, filePath);
-      if (!this.context.fileExists(rootedPath)) {
+      if (!this.compilerHost.fileExists(rootedPath)) {
        // If the file doesn't exists then we cannot return metadata for the file.
        // This will occur if the user refernced a declared module for which no file
        // exists for the module (i.e. jQuery or angularjs).
@@ -1,19 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * @module
- * @description
- * Entry point for all public APIs of the common package.
- */
-
-import {Version} from '@angular/core';
-/**
- * @stable
- */
-export const VERSION = new Version('0.0.0-PLACEHOLDER');
@@ -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';
@@ -15,13 +14,14 @@ import {Directory, Entry, MockAotContext, MockCompilerHost} from './mocks';

 describe('CompilerHost', () => {
  let context: MockAotContext;
+  let host: ts.CompilerHost;
  let program: ts.Program;
  let hostNestedGenDir: CompilerHost;
  let hostSiblingGenDir: CompilerHost;

  beforeEach(() => {
    context = new MockAotContext('/tmp/src', clone(FILES));
-    const host = new MockCompilerHost(context);
+    host = new MockCompilerHost(context);
    program = ts.createProgram(
        ['main.ts'], {
          module: ts.ModuleKind.CommonJS,
@@ -33,7 +33,7 @@ describe('CompilerHost', () => {
      throw new Error('Expected no errors');
    }
    hostNestedGenDir = new CompilerHost(
-        program, {
+        program, host, {
          genDir: '/tmp/project/src/gen/',
          basePath: '/tmp/project/src',
          skipMetadataEmit: false,
@@ -43,7 +43,7 @@ describe('CompilerHost', () => {
        },
        context);
    hostSiblingGenDir = new CompilerHost(
-        program, {
+        program, host, {
          genDir: '/tmp/project/gen',
          basePath: '/tmp/project/src/',
          skipMetadataEmit: false,
@@ -67,14 +67,11 @@ describe('CompilerHost', () => {
                 '/tmp/project/src/my.other.ngfactory.ts', '/tmp/project/src/my.ngfactory.ts'))
          .toEqual('./my.other.ngfactory');
      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.css.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css.ngstyle');
+                 '/tmp/project/src/my.other.css.ts', '/tmp/project/src/a/my.ngfactory.ts'))
+          .toEqual('../my.other.css');
      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.shim.ngstyle.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.shim.ngstyle');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.sass.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.sass.ngstyle');
+                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
+          .toEqual('./a/my.other.css.shim');
    });

    it('should import application from factory', () => {
@@ -87,12 +84,6 @@ describe('CompilerHost', () => {
      expect(hostNestedGenDir.fileNameToModuleName(
                 '/tmp/project/src/a/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
          .toEqual('../a/my.other');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../a/my.other.css');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../a/my.other.css.shim');
    });
  });

@@ -151,14 +142,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 ', () => {
@@ -169,36 +158,19 @@ describe('CompilerHost', () => {
    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/missing.d.ts')).toBeUndefined();
  });

-  it('should add missing v3 metadata from v1 metadata and .d.ts files', () => {
+  it('should add missing v2 metadata from v1 metadata and .d.ts files', () => {
    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1.d.ts')).toEqual([
      {__symbolic: 'module', version: 1, metadata: {foo: {__symbolic: 'class'}}}, {
        __symbolic: 'module',
-        version: 3,
-        metadata: {
-          foo: {__symbolic: 'class'},
-          Bar: {__symbolic: 'class', members: {ngOnInit: [{__symbolic: 'method'}]}},
-          BarChild: {__symbolic: 'class', extends: {__symbolic: 'reference', name: 'Bar'}},
-          ReExport: {__symbolic: 'reference', module: './lib/utils2', name: 'ReExport'},
-        },
-        exports: [{from: './lib/utils2', export: ['Export']}],
+        version: 2,
+        metadata: {foo: {__symbolic: 'class'}, bar: {__symbolic: 'class'}}
      }
    ]);
  });
-
-  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 +190,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;',
@@ -226,22 +198,9 @@ const FILES: Entry = {
        }
      },
      'metadata_versions': {
-        'v1.d.ts': `
-          import {ReExport} from './lib/utils2';
-          export {ReExport};
-
-          export {Export} from './lib/utils2';
-
-          export declare class Bar {
-            ngOnInit() {}
-          }
-          export declare class BarChild extends Bar {}
-        `,
+        'v1.d.ts': 'export declare class bar {}',
        'v1.metadata.json':
            `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
-        'v1_empty.d.ts': `
-          export * from './lib/utils';
-        `
      }
    }
  }
@@ -1,181 +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 {makeTempDir} from '@angular/tsc-wrapped/test/test_support';
-import * as fs from 'fs';
-import * as path from 'path';
-
-import {main} from '../src/main';
-import {ReflectionCapabilities, reflector} from './private_import_core';
-
-
-describe('compiler-cli', () => {
-  let basePath: string;
-  let write: (fileName: string, content: string) => void;
-
-  beforeEach(() => {
-    basePath = makeTempDir();
-    write = (fileName: string, content: string) => {
-      fs.writeFileSync(path.join(basePath, fileName), content, {encoding: 'utf-8'});
-    };
-    write('tsconfig.json', `{
-      "compilerOptions": {
-        "experimentalDecorators": true,
-        "types": [],
-        "outDir": "built",
-        "declaration": true,
-        "module": "es2015",
-        "moduleResolution": "node"
-      },
-      "angularCompilerOptions": {
-        "annotateForClosureCompiler": true
-      },
-      "files": ["test.ts"]
-    }`);
-    const nodeModulesPath = path.resolve(basePath, 'node_modules');
-    fs.mkdirSync(nodeModulesPath);
-    fs.symlinkSync(path.resolve(__dirname, '..', '..'), path.resolve(nodeModulesPath, '@angular'));
-  });
-
-  // Restore reflector since AoT compiler will update it with a new static reflector
-  afterEach(() => { reflector.updateCapabilities(new ReflectionCapabilities()); });
-
-  it('should compile without errors', (done) => {
-    write('test.ts', 'export const A = 1;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error).not.toHaveBeenCalled();
-          expect(exitCode).toEqual(0);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if user input file does not exist', (done) => {
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  `Error File '` + path.join(basePath, 'test.ts') + `' not found.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if user input file is malformed', (done) => {
-    write('test.ts', 'foo;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') + `:1:1: Cannot find name 'foo'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if cannot find the imported module', (done) => {
-    write('test.ts', `import {MyClass} from './not-exist-deps';`);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') +
-                  `:1:23: Cannot find module './not-exist-deps'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if cannot import', (done) => {
-    write('empty-deps.ts', 'export const A = 1;');
-    write('test.ts', `import {MyClass} from './empty-deps';`);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') + `:1:9: Module '"` +
-                  path.join(basePath, 'empty-deps') + `"' has no exported member 'MyClass'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if type mismatches', (done) => {
-    write('empty-deps.ts', 'export const A = "abc";');
-    write('test.ts', `
-      import {A} from './empty-deps';
-      A();
-    `);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') +
-                  ':3:7: Cannot invoke an expression whose type lacks a call signature.');
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should print the stack trace on compiler internal errors', (done) => {
-    write('test.ts', 'export const A = 1;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: 'not-exist'}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error).toHaveBeenCalled();
-          expect(mockConsole.error).toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-});
@@ -1,13 +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 {__core_private__ as r} from '@angular/core';
-
-export type ReflectionCapabilities = typeof r._ReflectionCapabilities;
-export var ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
-export var reflector: typeof r.reflector = r.reflector;
@@ -1,34 +0,0 @@
-{
-    "compilerOptions": {
-        "baseUrl": ".",
-        "declaration": true,
-        "experimentalDecorators": true,
-        "noImplicitAny": true,
-        "module": "es2015",
-        "moduleResolution": "node",
-        "outDir": "../../../dist/esm/compiler-cli",
-        "paths": {
-          "@angular/core": ["../../../dist/packages-dist/core"],
-          "@angular/common": ["../../../dist/packages-dist/common"],
-          "@angular/compiler": ["../../../dist/packages-dist/compiler"],
-          "@angular/platform-server": ["../../../dist/packages-dist/platform-server"],
-          "@angular/platform-browser": ["../../../dist/packages-dist/platform-browser"],
-          "@angular/tsc-wrapped": ["../../../dist/tools/@angular/tsc-wrapped"]
-        },
-        "rootDir": ".",
-        "sourceMap": true,
-        "inlineSources": true,
-        "target": "es5",
-        "lib": ["es6", "dom"],
-        "skipLibCheck": true
-    },
-    "exclude": ["integrationtest"],
-    "files": [
-        "index.ts",
-        "src/main.ts",
-        "src/extract_i18n.ts",
-        "../../../node_modules/@types/node/index.d.ts",
-        "../../../node_modules/@types/jasmine/index.d.ts",
-        "../../../node_modules/zone.js/dist/zone.js.d.ts"
-    ]
-}
@@ -1,11 +1,11 @@
 {
    "compilerOptions": {
-        "baseUrl": ".",
-        "declaration": true,
-        "experimentalDecorators": true,
-        "noImplicitAny": true,
        "module": "commonjs",
-        "outDir": "../../../dist/packages-dist/compiler-cli",
+        "target": "es5",
+        "lib": ["es6", "dom"],
+        "noImplicitAny": true,
+        "sourceMap": true,
+        "baseUrl": ".",
        "paths": {
          "@angular/core": ["../../../dist/packages-dist/core"],
          "@angular/common": ["../../../dist/packages-dist/common"],
@@ -14,11 +14,11 @@
          "@angular/platform-browser": ["../../../dist/packages-dist/platform-browser"],
          "@angular/tsc-wrapped": ["../../../dist/tools/@angular/tsc-wrapped"]
        },
+        "experimentalDecorators": true,
        "rootDir": ".",
-        "sourceMap": true,
-        "inlineSources": true,
-        "target": "es5",
-        "lib": ["es6", "dom"],
+        "sourceRoot": ".",
+        "outDir": "../../../dist/packages-dist/compiler-cli",
+        "declaration": true,
        "skipLibCheck": true
    },
    "exclude": ["integrationtest"],
@@ -21,7 +21,6 @@
 *   </p>
 * </div>
 */
-export {VERSION} from './src/version';
 export * from './src/template_parser/template_ast';
 export {TEMPLATE_TRANSFORMS} from './src/template_parser/template_parser';
 export {CompilerConfig, RenderTypes} from './src/config';
@@ -32,9 +31,6 @@ 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 +58,5 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
-export {SyntaxError} from './src/util';
+
 // This file only reexports content of the `src` folder. Keep it that way.
@@ -8,7 +8,7 @@


 import {isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ANY_STATE, DEFAULT_STATE, EMPTY_STATE} from '../private_import_core';

@@ -66,11 +66,11 @@ 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([
-      o.importExpr(createIdentifier(Identifiers.collectAndResolveStyles)).callFn([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationStyles)).instantiate([
+      o.importExpr(resolveIdentifier(Identifiers.collectAndResolveStyles)).callFn([
        _ANIMATION_COLLECTED_STYLES, o.literalArr(stylesArr)
      ])
    ]);
@@ -78,7 +78,7 @@ class _AnimationBuilder implements AnimationAstVisitor {

  visitAnimationKeyframe(ast: AnimationKeyframeAst, context: _AnimationBuilderContext):
      o.Expression {
-    return o.importExpr(createIdentifier(Identifiers.AnimationKeyframe)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationKeyframe)).instantiate([
      o.literal(ast.offset), ast.styles.visit(this, context)
    ]);
  }
@@ -100,7 +100,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
    const startingStylesExpr = ast.startingStyles.visit(this, context);
    const keyframeExpressions = ast.keyframes.map(keyframe => keyframe.visit(this, context));
    const keyframesExpr =
-        o.importExpr(createIdentifier(Identifiers.balanceAnimationKeyframes)).callFn([
+        o.importExpr(resolveIdentifier(Identifiers.balanceAnimationKeyframes)).callFn([
          _ANIMATION_COLLECTED_STYLES, _ANIMATION_END_STATE_STYLES_VAR,
          o.literalArr(keyframeExpressions)
        ]);
@@ -127,14 +127,14 @@ class _AnimationBuilder implements AnimationAstVisitor {
  visitAnimationSequence(ast: AnimationSequenceAst, context: _AnimationBuilderContext):
      o.Expression {
    const playerExprs = ast.steps.map(step => step.visit(this, context));
-    return o.importExpr(createIdentifier(Identifiers.AnimationSequencePlayer)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationSequencePlayer)).instantiate([
      o.literalArr(playerExprs)
    ]);
  }

  visitAnimationGroup(ast: AnimationGroupAst, context: _AnimationBuilderContext): o.Expression {
    const playerExprs = ast.steps.map(step => step.visit(this, context));
-    return o.importExpr(createIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
      o.literalArr(playerExprs)
    ]);
  }
@@ -199,9 +199,8 @@ class _AnimationBuilder implements AnimationAstVisitor {
                        .set(_ANIMATION_FACTORY_VIEW_CONTEXT.callMethod(
                            'getAnimationPlayers',
                            [
-                              _ANIMATION_FACTORY_ELEMENT_VAR,
+                              _ANIMATION_FACTORY_ELEMENT_VAR, o.literal(this.animationName),
                              _ANIMATION_NEXT_STATE_VAR.equals(o.literal(EMPTY_STATE))
-                                  .conditional(o.NULL_EXPR, o.literal(this.animationName))
                            ]))
                        .toDeclStmt());

@@ -229,7 +228,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
        _ANIMATION_END_STATE_STYLES_VAR.equals(o.NULL_EXPR),
        [_ANIMATION_END_STATE_STYLES_VAR.set(_ANIMATION_DEFAULT_STATE_VAR).toStmt()]));

-    const RENDER_STYLES_FN = o.importExpr(createIdentifier(Identifiers.renderStyles));
+    const RENDER_STYLES_FN = o.importExpr(resolveIdentifier(Identifiers.renderStyles));

    ast.stateTransitions.forEach(transAst => statements.push(transAst.visit(this, context)));

@@ -238,7 +237,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
    statements.push(new o.IfStmt(
        _ANIMATION_PLAYER_VAR.equals(o.NULL_EXPR),
        [_ANIMATION_PLAYER_VAR
-             .set(o.importExpr(createIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
+             .set(o.importExpr(resolveIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
             .toStmt()]));

    // once complete we want to apply the styles on the element
@@ -256,18 +255,17 @@ class _AnimationBuilder implements AnimationAstVisitor {
                               .callFn([
                                 _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
                                 o.importExpr(
-                                      createIdentifier(Identifiers.prepareFinalAnimationStyles))
-                                     .callFn(
-                                         [
-                                           _ANIMATION_START_STATE_STYLES_VAR,
-                                           _ANIMATION_END_STATE_STYLES_VAR
-                                         ])
+                                      resolveIdentifier(Identifiers.prepareFinalAnimationStyles))
+                                     .callFn([
+                                       _ANIMATION_START_STATE_STYLES_VAR,
+                                       _ANIMATION_END_STATE_STYLES_VAR
+                                     ])
                               ])
                               .toStmt()
                         ])])
            .toStmt());

-    statements.push(o.importExpr(createIdentifier(Identifiers.AnimationSequencePlayer))
+    statements.push(o.importExpr(resolveIdentifier(Identifiers.AnimationSequencePlayer))
                        .instantiate([_PREVIOUS_ANIMATION_PLAYERS])
                        .callMethod('destroy', [])
                        .toStmt());
@@ -278,7 +276,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
    statements.push(RENDER_STYLES_FN
                        .callFn([
                          _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
-                          o.importExpr(createIdentifier(Identifiers.clearStyles))
+                          o.importExpr(resolveIdentifier(Identifiers.clearStyles))
                              .callFn([_ANIMATION_START_STATE_STYLES_VAR])
                        ])
                        .toStmt());
@@ -293,7 +291,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
                        .toStmt());

    statements.push(new o.ReturnStatement(
-        o.importExpr(createIdentifier(Identifiers.AnimationTransition)).instantiate([
+        o.importExpr(resolveIdentifier(Identifiers.AnimationTransition)).instantiate([
          _ANIMATION_PLAYER_VAR, _ANIMATION_CURRENT_STATE_VAR, _ANIMATION_NEXT_STATE_VAR,
          _ANIMATION_TIME_VAR
        ])));
@@ -302,12 +300,12 @@ class _AnimationBuilder implements AnimationAstVisitor {
        [
          new o.FnParam(
              _ANIMATION_FACTORY_VIEW_VAR.name,
-              o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+              o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
          new o.FnParam(_ANIMATION_FACTORY_ELEMENT_VAR.name, o.DYNAMIC_TYPE),
          new o.FnParam(_ANIMATION_CURRENT_STATE_VAR.name, o.DYNAMIC_TYPE),
          new o.FnParam(_ANIMATION_NEXT_STATE_VAR.name, o.DYNAMIC_TYPE)
        ],
-        statements, o.importType(createIdentifier(Identifiers.AnimationTransition)));
+        statements, o.importType(resolveIdentifier(Identifiers.AnimationTransition)));
  }

  build(ast: AnimationAst): AnimationEntryCompileResult {
@@ -322,13 +320,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);
@@ -6,10 +6,11 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata, identifierName} from '../compile_metadata';
+import {Injectable} from '@angular/core';
+
+import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata} 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,13 +35,13 @@ export class AnimationEntryParseResult {
  constructor(public ast: AnimationEntryAst, public errors: AnimationParseError[]) {}
 }

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

  parseComponent(component: CompileDirectiveMetadata): AnimationEntryAst[] {
    const errors: string[] = [];
-    const componentName = identifierName(component.type);
+    const componentName = component.type.name;
    const animationTriggerNames = new Set<string>();
    const asts = component.template.animations.map(entry => {
      const result = this.parseEntry(entry);
@@ -173,11 +174,6 @@ function _normalizeStyleMetadata(
    entry: CompileAnimationStyleMetadata, stateStyles: {[key: string]: AnimationStylesAst},
    schema: ElementSchemaRegistry, errors: AnimationParseError[],
    permitStateReferences: boolean): {[key: string]: string | number}[] {
-  const offset = entry.offset;
-  if (offset > 1 || offset < 0) {
-    errors.push(new AnimationParseError(`Offset values for animations must be between 0 and 1`));
-  }
-
  const normalizedStyles: {[key: string]: string | number}[] = [];
  entry.styles.forEach(styleEntry => {
    if (typeof styleEntry === 'string') {
@@ -10,67 +10,60 @@ import {SchemaMetadata} from '@angular/core';

 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, CompileTypeSummary, createHostComponentMeta, identifierModuleUrl, identifierName} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, createHostComponentMeta} from '../compile_metadata';
 import {DirectiveNormalizer} from '../directive_normalizer';
 import {DirectiveWrapperCompileResult, DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {ListWrapper} from '../facade/collection';
-import {Identifiers, createIdentifier, createIdentifierToken} from '../identifiers';
+import {Identifiers, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
 import {CompileMetadataResolver} from '../metadata_resolver';
 import {NgModuleCompiler} from '../ng_module_compiler';
 import {OutputEmitter} from '../output/abstract_emitter';
 import * as o from '../output/output_ast';
 import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
-import {SummaryResolver} from '../summary_resolver';
 import {TemplateParser} from '../template_parser/template_parser';
 import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';

-import {AotCompilerHost} from './compiler_host';
-import {GeneratedFile} from './generated_file';
+import {AotCompilerOptions} from './compiler_options';
+import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-import {serializeSummaries, summaryFileName} from './summary_serializer';
+
+export class SourceModule {
+  constructor(public fileUrl: string, public moduleUrl: string, public source: string) {}
+}

 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 _translationFormat: string, private _animationParser: AnimationParser,
-      private _symbolResolver: StaticSymbolResolver) {}
+      private _localeId: string, private _translationFormat: string,
+      private _animationParser: AnimationParser, private _staticReflector: StaticReflector,
+      private _options: AotCompilerOptions) {}

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

-  compileAll(rootFiles: string[]): Promise<GeneratedFile[]> {
-    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
+  compileAll(rootFiles: string[]): Promise<SourceModule[]> {
+    const programSymbols = extractProgramSymbols(this._staticReflector, rootFiles, this._options);
    const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
-    return Promise
-        .all(ngModules.map(
-            ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
-                ngModule.type.reference, false)))
-        .then(() => {
-          const sourceModules = files.map(
-              file => this._compileSrcFile(
-                  file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.pipes,
-                  file.ngModules, file.injectables));
-          return ListWrapper.flatten(sourceModules);
-        });
+        analyzeAndValidateNgModules(programSymbols, this._options, this._metadataResolver);
+    return loadNgModuleDirectives(ngModules).then(() => {
+      const sourceModules = files.map(
+          file => this._compileSrcFile(
+              file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.ngModules));
+      return ListWrapper.flatten(sourceModules);
+    });
  }

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

    // compile all ng modules
    exportedVars.push(
@@ -89,7 +82,7 @@ export class AotCompiler {
      const ngModule = ngModuleByPipeOrDirective.get(dirType);
      if (!ngModule) {
        throw new Error(
-            `Internal Error: cannot determine the module for component ${identifierName(compMeta.type)}!`);
+            `Internal Error: cannot determine the module for component ${compMeta.type.name}!`);
      }

      _assertComponent(compMeta);
@@ -97,7 +90,7 @@ export class AotCompiler {
      // compile styles
      const stylesCompileResults = this._styleCompiler.compileComponent(compMeta);
      stylesCompileResults.externalStylesheets.forEach((compiledStyleSheet) => {
-        generatedFiles.push(this._codgenStyles(srcFileUrl, compiledStyleSheet, fileSuffix));
+        outputSourceModules.push(this._codgenStyles(srcFileUrl, compiledStyleSheet, fileSuffix));
      });

      // compile components
@@ -110,25 +103,9 @@ export class AotCompiler {
    if (statements.length > 0) {
      const srcModule = this._codegenSourceModule(
          srcFileUrl, _ngfactoryModuleUrl(srcFileUrl), statements, exportedVars);
-      generatedFiles.unshift(srcModule);
+      outputSourceModules.unshift(srcModule);
    }
-    return generatedFiles;
-  }
-
-  private _createSummary(
-      srcFileUrl: string, directives: StaticSymbol[], pipes: StaticSymbol[],
-      ngModules: StaticSymbol[], injectables: StaticSymbol[]): GeneratedFile {
-    const symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileUrl)
-                                .map(symbol => this._symbolResolver.resolveSymbol(symbol));
-    const typeSummaries = [
-      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
-      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
-      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref)),
-      ...injectables.map(ref => this._metadataResolver.getInjectableSummary(ref))
-    ];
-    const json = serializeSummaries(
-        this._host, this._summaryResolver, this._symbolResolver, symbolSummaries, typeSummaries);
-    return new GeneratedFile(srcFileUrl, summaryFileName(srcFileUrl), json);
+    return outputSourceModules;
  }

  private _compileModule(ngModuleType: StaticSymbol, targetStatements: o.Statement[]): string {
@@ -136,24 +113,24 @@ export class AotCompiler {
    const providers: CompileProviderMetadata[] = [];

    if (this._localeId) {
-      providers.push({
-        token: createIdentifierToken(Identifiers.LOCALE_ID),
+      providers.push(new CompileProviderMetadata({
+        token: resolveIdentifierToken(Identifiers.LOCALE_ID),
        useValue: this._localeId,
-      });
+      }));
    }

    if (this._translationFormat) {
-      providers.push({
-        token: createIdentifierToken(Identifiers.TRANSLATIONS_FORMAT),
+      providers.push(new CompileProviderMetadata({
+        token: resolveIdentifierToken(Identifiers.TRANSLATIONS_FORMAT),
        useValue: this._translationFormat
-      });
+      }));
    }

    const appCompileResult = this._ngModuleCompiler.compile(ngModule, providers);

    appCompileResult.dependencies.forEach((dep) => {
-      dep.placeholder.reference = this._symbolResolver.getStaticSymbol(
-          _ngfactoryModuleUrl(identifierModuleUrl(dep.comp)), _componentFactoryName(dep.comp));
+      dep.placeholder.name = _componentFactoryName(dep.comp);
+      dep.placeholder.moduleUrl = _ngfactoryModuleUrl(dep.comp.moduleUrl);
    });

    targetStatements.push(...appCompileResult.statements);
@@ -172,17 +149,14 @@ export class AotCompiler {
  private _compileComponentFactory(
      compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata, fileSuffix: string,
      targetStatements: o.Statement[]): string {
-    const hostMeta = createHostComponentMeta(
-        this._symbolResolver.getStaticSymbol(
-            identifierModuleUrl(compMeta.type), `${identifierName(compMeta.type)}_Host`),
-        compMeta);
+    const hostMeta = createHostComponentMeta(compMeta);
    const hostViewFactoryVar = this._compileComponent(
        hostMeta, ngModule, [compMeta.type], null, fileSuffix, targetStatements);
    const compFactoryVar = _componentFactoryName(compMeta.type);
    targetStatements.push(
        o.variable(compFactoryVar)
-            .set(o.importExpr(
-                      createIdentifier(Identifiers.ComponentFactory), [o.importType(compMeta.type)])
+            .set(o.importExpr(resolveIdentifier(Identifiers.ComponentFactory), [o.importType(
+                                                                                   compMeta.type)])
                     .instantiate(
                         [
                           o.literal(compMeta.selector),
@@ -190,7 +164,7 @@ export class AotCompiler {
                           o.importExpr(compMeta.type),
                         ],
                         o.importType(
-                             createIdentifier(Identifiers.ComponentFactory),
+                             resolveIdentifier(Identifiers.ComponentFactory),
                             [o.importType(compMeta.type)], [o.TypeModifier.Const])))
            .toDeclStmt(null, [o.StmtModifier.Final]));
    return compFactoryVar;
@@ -208,24 +182,23 @@ export class AotCompiler {

    const parsedTemplate = this._templateParser.parse(
        compMeta, compMeta.template.template, directives, pipes, ngModule.schemas,
-        identifierName(compMeta.type));
+        compMeta.type.name);
    const stylesExpr = componentStyles ? o.variable(componentStyles.stylesVar) : o.literalArr([]);
    const compiledAnimations =
-        this._animationCompiler.compile(identifierName(compMeta.type), parsedAnimations);
+        this._animationCompiler.compile(compMeta.type.name, parsedAnimations);
    const viewResult = this._viewCompiler.compileComponent(
        compMeta, parsedTemplate, stylesExpr, pipes, compiledAnimations);
    if (componentStyles) {
-      targetStatements.push(
-          ..._resolveStyleStatements(this._symbolResolver, componentStyles, fileSuffix));
+      targetStatements.push(..._resolveStyleStatements(componentStyles, fileSuffix));
    }
    compiledAnimations.forEach(entry => targetStatements.push(...entry.statements));
-    targetStatements.push(..._resolveViewStatements(this._symbolResolver, viewResult));
+    targetStatements.push(..._resolveViewStatements(viewResult));
    return viewResult.viewClassVar;
  }

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

  private _codegenSourceModule(
-      srcFileUrl: string, genFileUrl: string, statements: o.Statement[],
-      exportedVars: string[]): GeneratedFile {
-    return new GeneratedFile(
-        srcFileUrl, genFileUrl,
-        this._outputEmitter.emitStatements(genFileUrl, statements, exportedVars));
+      fileUrl: string, moduleUrl: string, statements: o.Statement[],
+      exportedVars: string[]): SourceModule {
+    return new SourceModule(
+        fileUrl, moduleUrl,
+        this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
  }
 }

-function _resolveViewStatements(
-    reflector: StaticSymbolResolver, compileResult: ViewCompileResult): o.Statement[] {
+function _resolveViewStatements(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);
+      vfd.placeholder.moduleUrl = _ngfactoryModuleUrl(vfd.comp.moduleUrl);
    } else if (dep instanceof ComponentFactoryDependency) {
      const cfd = <ComponentFactoryDependency>dep;
-      cfd.placeholder.reference = reflector.getStaticSymbol(
-          _ngfactoryModuleUrl(identifierModuleUrl(cfd.comp)), _componentFactoryName(cfd.comp));
+      cfd.placeholder.name = _componentFactoryName(cfd.comp);
+      cfd.placeholder.moduleUrl = _ngfactoryModuleUrl(cfd.comp.moduleUrl);
    } else if (dep instanceof DirectiveWrapperDependency) {
      const dwd = <DirectiveWrapperDependency>dep;
-      dwd.placeholder.reference =
-          reflector.getStaticSymbol(_ngfactoryModuleUrl(identifierModuleUrl(dwd.dir)), dwd.name);
+      dwd.placeholder.moduleUrl = _ngfactoryModuleUrl(dwd.dir.moduleUrl);
    }
  });
  return compileResult.statements;
@@ -263,11 +233,9 @@ function _resolveViewStatements(


 function _resolveStyleStatements(
-    reflector: StaticSymbolResolver, compileResult: CompiledStylesheet,
-    fileSuffix: string): o.Statement[] {
+    compileResult: CompiledStylesheet, fileSuffix: string): o.Statement[] {
  compileResult.dependencies.forEach((dep) => {
-    dep.valuePlaceholder.reference = reflector.getStaticSymbol(
-        _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, fileSuffix), dep.name);
+    dep.valuePlaceholder.moduleUrl = _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, fileSuffix);
  });
  return compileResult.statements;
 }
@@ -278,17 +246,16 @@ function _ngfactoryModuleUrl(dirUrl: string): string {
 }

 function _componentFactoryName(comp: CompileIdentifierMetadata): string {
-  return `${identifierName(comp)}NgFactory`;
+  return `${comp.name}NgFactory`;
 }

 function _stylesModuleUrl(stylesheetUrl: string, shim: boolean, suffix: string): string {
-  return `${stylesheetUrl}${shim ? '.shim' : ''}.ngstyle${suffix}`;
+  return shim ? `${stylesheetUrl}.shim${suffix}` : `${stylesheetUrl}${suffix}`;
 }

 function _assertComponent(meta: CompileDirectiveMetadata) {
  if (!meta.isComponent) {
-    throw new Error(
-        `Could not compile '${identifierName(meta.type)}' because it is not a component.`);
+    throw new Error(`Could not compile '${meta.type.name}' because it is not a component.`);
  }
 }

@@ -309,31 +276,25 @@ function _splitTypescriptSuffix(path: string): string[] {
 export interface NgAnalyzedModules {
  ngModules: CompileNgModuleMetadata[];
  ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>;
-  files: Array<{
-    srcUrl: string,
-    directives: StaticSymbol[],
-    pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
-  }>;
+  files: Array<{srcUrl: string, directives: 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}!`);
@@ -342,32 +303,27 @@ export function analyzeAndValidateNgModules(
  return result;
 }

+// Wait for the directives in the given modules have been loaded
+export function loadNgModuleDirectives(ngModules: CompileNgModuleMetadata[]) {
+  return Promise
+      .all(ListWrapper.flatten(ngModules.map(
+          (ngModule) => ngModule.transitiveModule.directiveLoaders.map(loader => loader()))))
+      .then(() => {});
+}
+
 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`,
-  // - a map from file to pipes `ngPipesByFile`,
  // - a map from directive/pipe to module `ngModuleByPipeOrDirective`.
  ngModuleMetas.forEach((ngModuleMeta) => {
    const srcFileUrl = ngModuleMeta.type.reference.filePath;
@@ -385,26 +341,16 @@ function _analyzeNgModules(
    ngModuleMeta.declaredPipes.forEach((pipeIdentifier) => {
      const fileUrl = pipeIdentifier.reference.filePath;
      filePaths.add(fileUrl);
-      ngPipesByFile.set(
-          fileUrl, (ngPipesByFile.get(fileUrl) || []).concat(pipeIdentifier.reference));
      ngModuleByPipeOrDirective.set(pipeIdentifier.reference, ngModuleMeta);
    });
  });

-  const files: {
-    srcUrl: string,
-    directives: StaticSymbol[],
-    pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
-  }[] = [];
+  const files: {srcUrl: string, directives: 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, ngModules});
  });

  return {
@@ -417,20 +363,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.log(`WARNING: no metadata found for ${sourceFile}`);
+      return;
+    }
+
+    const metadata = moduleMetadata['metadata'];
+
+    if (!metadata) {
+      return;
+    }
+
+    for (const symbol of Object.keys(metadata)) {
+      if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
+        // Ignore symbols that are only included to record error information.
+        continue;
      }
-    });
+      staticSymbols.push(staticReflector.getStaticSymbol(sourceFile, symbol));
+    }
  });

  return staticSymbols;
@@ -440,7 +395,8 @@ export function extractProgramSymbols(
 // that all directives / pipes that are present in the program
 // are also declared by a module.
 function _createNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
    metadataResolver: CompileMetadataResolver):
    {ngModules: CompileNgModuleMetadata[], symbolsMissingModule: StaticSymbol[]} {
  const ngModules = new Map<any, CompileNgModuleMetadata>();
@@ -448,16 +404,16 @@ 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);
+    const ngModule = metadataResolver.getUnloadedNgModuleMetadata(staticSymbol, false, false);
    if (ngModule) {
      ngModules.set(ngModule.type.reference, ngModule);
      ngModule.declaredDirectives.forEach((dir) => ngModulePipesAndDirective.add(dir.reference));
      ngModule.declaredPipes.forEach((pipe) => ngModulePipesAndDirective.add(pipe.reference));
      // For every input module add the list of transitively included modules
-      ngModule.transitiveModule.modules.forEach(modMeta => addNgModule(modMeta.reference));
+      ngModule.transitiveModule.modules.forEach(modMeta => addNgModule(modMeta.type.reference));
    }
    return !!ngModule;
  };
@@ -474,3 +430,15 @@ function _createNgModules(

  return {ngModules: Array.from(ngModules.values()), symbolsMissingModule};
 }
+
+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;
+}
@@ -34,9 +34,7 @@ import {AotCompilerHost} from './compiler_host';
 import {AotCompilerOptions} from './compiler_options';
 import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
 import {StaticReflector} from './static_reflector';
-import {StaticSymbolCache} from './static_symbol';
-import {StaticSymbolResolver} from './static_symbol_resolver';
-import {AotSummaryResolver} from './summary_resolver';
+


 /**
@@ -47,10 +45,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({
@@ -68,14 +63,13 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
      new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
  const resolver = new CompileMetadataResolver(
      new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-      new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-      staticReflector);
+      new PipeResolver(staticReflector), elementSchemaRegistry, normalizer, staticReflector);
  // TODO(vicb): do not pass options.i18nFormat here
  const compiler = new AotCompiler(
-      compilerHost, resolver, tmplParser, new StyleCompiler(urlResolver),
+      resolver, tmplParser, new StyleCompiler(urlResolver),
      new ViewCompiler(config, elementSchemaRegistry),
      new DirectiveWrapperCompiler(config, expressionParser, elementSchemaRegistry, console),
-      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), summaryResolver, options.locale,
-      options.i18nFormat, new AnimationParser(elementSchemaRegistry), symbolResolver);
+      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), options.locale,
+      options.i18nFormat, new AnimationParser(elementSchemaRegistry), staticReflector, options);
  return {compiler, reflector: staticReflector};
 }
@@ -8,19 +8,17 @@

 import {ImportResolver} from '../output/path_util';

+import {StaticReflectorHost} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {StaticSymbolResolverHost} from './static_symbol_resolver';
-import {AotSummaryResolverHost} from './summary_resolver';
-import {AotSummarySerializerHost} from './summary_serializer';
+

 /**
 * The host of the AotCompiler disconnects the implementation from TypeScript / other language
 * services and from underlying file systems.
 */
-export interface AotCompilerHost extends StaticSymbolResolverHost, ImportResolver,
-    AotSummaryResolverHost, AotSummarySerializerHost {
+export interface AotCompilerHost extends StaticReflectorHost, ImportResolver {
  /**
   * Loads a resource (e.g. html / css)
   */
  loadResource(path: string): Promise<string>;
-}
+}
@@ -11,4 +11,6 @@ export interface AotCompilerOptions {
  locale?: string;
  i18nFormat?: string;
  translations?: string;
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
 }
@@ -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)) {
@@ -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 = 2;
 const ANGULAR_IMPORT_LOCATIONS = {
  coreDecorators: '@angular/core/src/metadata',
  diDecorators: '@angular/core/src/di/metadata',
@@ -22,54 +20,75 @@ const ANGULAR_IMPORT_LOCATIONS = {
  provider: '@angular/core/src/di/provider'
 };

-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 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,
-      knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
-      knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
-      private errorRecorder?: (error: any, fileName: string) => void) {
+      private host: StaticReflectorHost,
+      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache()) {
    this.initializeConversionMap();
-    knownMetadataClasses.forEach(
-        (kc) => this._registerDecoratorOrConstructor(
-            this.getStaticSymbol(kc.filePath, kc.name), kc.ctor));
-    knownMetadataFunctions.forEach(
-        (kf) => this._registerFunction(this.getStaticSymbol(kf.filePath, kf.name), kf.fn));
  }

  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 {
@@ -80,45 +99,29 @@ export class StaticReflector implements ReflectorReader {
  public annotations(type: StaticSymbol): any[] {
    let annotations = this.annotationCache.get(type);
    if (!annotations) {
-      annotations = [];
      const classMetadata = this.getTypeMetadata(type);
-      if (classMetadata['extends']) {
-        const parentAnnotations = this.annotations(this.simplify(type, classMetadata['extends']));
-        annotations.push(...parentAnnotations);
-      }
      if (classMetadata['decorators']) {
-        const ownAnnotations: any[] = this.simplify(type, classMetadata['decorators']);
-        annotations.push(...ownAnnotations);
+        annotations = this.simplify(type, classMetadata['decorators']);
+      } else {
+        annotations = [];
      }
      this.annotationCache.set(type, annotations.filter(ann => !!ann));
    }
    return annotations;
  }

-  public propMetadata(type: StaticSymbol): {[key: string]: any[]} {
+  public propMetadata(type: StaticSymbol): {[key: string]: any} {
    let propMetadata = this.propertyCache.get(type);
    if (!propMetadata) {
      const classMetadata = this.getTypeMetadata(type);
-      propMetadata = {};
-      if (classMetadata['extends']) {
-        const parentPropMetadata = this.propMetadata(this.simplify(type, classMetadata['extends']));
-        Object.keys(parentPropMetadata).forEach((parentProp) => {
-          propMetadata[parentProp] = parentPropMetadata[parentProp];
-        });
-      }
-
-      const members = classMetadata['members'] || {};
-      Object.keys(members).forEach((propName) => {
-        const propData = members[propName];
+      const members = classMetadata ? classMetadata['members'] : {};
+      propMetadata = mapStringMap(members, (propData, propName) => {
        const prop = (<any[]>propData)
                         .find(a => a['__symbolic'] == 'property' || a['__symbolic'] == 'method');
-        const decorators: any[] = [];
-        if (propMetadata[propName]) {
-          decorators.push(...propMetadata[propName]);
-        }
-        propMetadata[propName] = decorators;
        if (prop && prop['decorators']) {
-          decorators.push(...this.simplify(type, prop['decorators']));
+          return this.simplify(type, prop['decorators']);
+        } else {
+          return [];
        }
      });
      this.propertyCache.set(type, propMetadata);
@@ -128,10 +131,7 @@ export class StaticReflector implements ReflectorReader {

  public parameters(type: StaticSymbol): any[] {
    if (!(type instanceof StaticSymbol)) {
-      this.reportError(
-          new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`),
-          type);
-      return [];
+      throw new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`);
    }
    try {
      let parameters = this.parameterCache.get(type);
@@ -155,8 +155,6 @@ export class StaticReflector implements ReflectorReader {
            }
            parameters.push(nestedResult);
          });
-        } else if (classMetadata['extends']) {
-          parameters = this.parameters(this.simplify(type, classMetadata['extends']));
        }
        if (!parameters) {
          parameters = [];
@@ -165,54 +163,28 @@ export class StaticReflector implements ReflectorReader {
      }
      return parameters;
    } catch (e) {
-      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
+      console.log(`Failed on type ${JSON.stringify(type)} with error ${e}`);
      throw e;
    }
  }

-  private _methodNames(type: any): {[key: string]: boolean} {
-    let methodNames = this.methodCache.get(type);
-    if (!methodNames) {
-      const classMetadata = this.getTypeMetadata(type);
-      methodNames = {};
-      if (classMetadata['extends']) {
-        const parentMethodNames = this._methodNames(this.simplify(type, classMetadata['extends']));
-        Object.keys(parentMethodNames).forEach((parentProp) => {
-          methodNames[parentProp] = parentMethodNames[parentProp];
-        });
-      }
-
-      const members = classMetadata['members'] || {};
-      Object.keys(members).forEach((propName) => {
-        const propData = members[propName];
-        const isMethod = (<any[]>propData).some(a => a['__symbolic'] == 'method');
-        methodNames[propName] = methodNames[propName] || isMethod;
-      });
-      this.methodCache.set(type, methodNames);
-    }
-    return methodNames;
-  }
-
  hasLifecycleHook(type: any, lcProperty: string): boolean {
    if (!(type instanceof StaticSymbol)) {
-      this.reportError(
-          new Error(
-              `hasLifecycleHook received ${JSON.stringify(type)} which is not a StaticSymbol`),
-          type);
-    }
-    try {
-      return !!this._methodNames(type)[lcProperty];
-    } catch (e) {
-      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
-      throw e;
+      throw new Error(
+          `hasLifecycleHook received ${JSON.stringify(type)} which is not a StaticSymbol`);
    }
+    const classMetadata = this.getTypeMetadata(type);
+    const members = classMetadata ? classMetadata['members'] : null;
+    const member: any[] =
+        members && members.hasOwnProperty(lcProperty) ? members[lcProperty] : null;
+    return member ? member.some(a => a['__symbolic'] == 'method') : false;
  }

-  private _registerDecoratorOrConstructor(type: StaticSymbol, ctor: any): void {
+  private registerDecoratorOrConstructor(type: StaticSymbol, ctor: any): void {
    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => new ctor(...args));
  }

-  private _registerFunction(type: StaticSymbol, fn: any): void {
+  private registerFunction(type: StaticSymbol, fn: any): void {
    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => fn.apply(undefined, args));
  }

@@ -221,51 +193,50 @@ export class StaticReflector implements ReflectorReader {
        ANGULAR_IMPORT_LOCATIONS;
    this.opaqueToken = this.findDeclaration(diOpaqueToken, 'OpaqueToken');

-    this._registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Host'), Host);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Host'), Host);
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(diDecorators, 'Injectable'), Injectable);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Self'), Self);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'SkipSelf'), SkipSelf);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Inject'), Inject);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Optional'), Optional);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Self'), Self);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'SkipSelf'), SkipSelf);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Inject'), Inject);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diDecorators, 'Optional'), Optional);
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'Attribute'), Attribute);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'ContentChild'), ContentChild);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'ContentChildren'), ContentChildren);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'ViewChild'), ViewChild);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'ViewChildren'), ViewChildren);
-    this._registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Input'), Input);
-    this._registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Output'), Output);
-    this._registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Pipe'), Pipe);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Input'), Input);
+    this.registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Output'), Output);
+    this.registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'Pipe'), Pipe);
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'HostBinding'), HostBinding);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'HostListener'), HostListener);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'Directive'), Directive);
-    this._registerDecoratorOrConstructor(
+    this.registerDecoratorOrConstructor(
        this.findDeclaration(coreDecorators, 'Component'), Component);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'NgModule'), NgModule);
+    this.registerDecoratorOrConstructor(this.findDeclaration(coreDecorators, 'NgModule'), NgModule);

    // Note: Some metadata classes can be used directly with Provider.deps.
-    this._registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Host'), Host);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Self'), Self);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'SkipSelf'), SkipSelf);
-    this._registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Optional'), Optional);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Host'), Host);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Self'), Self);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'SkipSelf'), SkipSelf);
+    this.registerDecoratorOrConstructor(this.findDeclaration(diMetadata, 'Optional'), Optional);

-    this._registerFunction(this.findDeclaration(animationMetadata, 'trigger'), trigger);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'state'), state);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'transition'), transition);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'style'), style);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'animate'), animate);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'keyframes'), keyframes);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'sequence'), sequence);
-    this._registerFunction(this.findDeclaration(animationMetadata, 'group'), group);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'trigger'), trigger);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'state'), state);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'transition'), transition);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'style'), style);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'animate'), animate);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'keyframes'), keyframes);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'sequence'), sequence);
+    this.registerFunction(this.findDeclaration(animationMetadata, 'group'), group);
  }

  /**
@@ -276,59 +247,184 @@ 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) {
-    if (this.errorRecorder) {
-      this.errorRecorder(error, (context && context.filePath) || path);
-    } else {
-      throw error;
+  private resolveExportedSymbol(filePath: string, symbolName: string): StaticSymbol {
+    const resolveModule = (moduleName: string): string => {
+      const resolvedModulePath = this.host.moduleNameToFileName(moduleName, filePath);
+      if (!resolvedModulePath) {
+        throw new Error(`Could not resolve module '${moduleName}' relative to file ${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;
+              }
+              staticSymbol = this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+            }
+          }
+        }
+
+        if (!staticSymbol) {
+          // Try to find the symbol via export * directives.
+          for (const moduleExport of metadata['exports']) {
+            if (!moduleExport.export) {
+              const resolvedModule = resolveModule(moduleExport.from);
+              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;
+    const _this = this;
    let scope = BindingScope.empty;
    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 =
+              _this.findDeclaration(expression['module'], expression['name'], context.filePath);
+        } else {
+          staticSymbol = _this.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 = _this.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), _this.opaqueToken);
          }
-          calling.set(functionSymbol, true);
-          try {
-            const value = targetFunction['value'];
-            if (value && (depth != 0 || value.__symbolic != 'error')) {
-              const parameters: string[] = targetFunction['parameters'];
-              const defaults: any[] = targetFunction.defaults;
-              if (defaults && defaults.length > args.length) {
-                args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
-              }
-              const functionScope = BindingScope.build();
-              for (let i = 0; i < parameters.length; i++) {
-                functionScope.define(parameters[i], args[i]);
-              }
-              const oldScope = scope;
-              let result: any;
-              try {
-                scope = functionScope.done();
-                result = simplifyInContext(functionSymbol, value, depth + 1);
-              } finally {
-                scope = oldScope;
-              }
-              return result;
+        }
+        return false;
+      }
+
+      function simplifyCall(expression: any) {
+        let callContext: {[name: string]: string}|undefined = undefined;
+        if (expression['__symbolic'] == 'call') {
+          const target = expression['expression'];
+          let functionSymbol: StaticSymbol;
+          let targetFunction: any;
+          if (target) {
+            switch (target.__symbolic) {
+              case 'reference':
+                // Find the function to call.
+                callContext = {name: target.name};
+                functionSymbol = resolveReference(context, target);
+                targetFunction = resolveReferenceValue(functionSymbol);
+                break;
+              case 'select':
+                // Find the static method to call
+                if (target.expression.__symbolic == 'reference') {
+                  functionSymbol = resolveReference(context, target.expression);
+                  const classData = resolveReferenceValue(functionSymbol);
+                  if (classData && classData.statics) {
+                    targetFunction = classData.statics[target.member];
+                  }
+                }
+                break;
+            }
+          }
+          if (targetFunction && targetFunction['__symbolic'] == 'function') {
+            if (calling.get(functionSymbol)) {
+              throw new Error('Recursion not supported');
+            }
+            calling.set(functionSymbol, true);
+            try {
+              const value = targetFunction['value'];
+              if (value && (depth != 0 || value.__symbolic != 'error')) {
+                // Determine the arguments
+                const args: any[] =
+                    (expression['arguments'] || []).map((arg: any) => simplify(arg));
+                const parameters: string[] = targetFunction['parameters'];
+                const defaults: any[] = targetFunction.defaults;
+                if (defaults && defaults.length > args.length) {
+                  args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
+                }
+                const functionScope = BindingScope.build();
+                for (let i = 0; i < parameters.length; i++) {
+                  functionScope.define(parameters[i], args[i]);
+                }
+                const oldScope = scope;
+                let result: any;
+                try {
+                  scope = functionScope.done();
+                  result = simplifyInContext(functionSymbol, value, depth + 1);
+                } finally {
+                  scope = oldScope;
+                }
+                return result;
+              }
+            } finally {
+              calling.delete(functionSymbol);
            }
-          } finally {
-            calling.delete(functionSymbol);
          }
        }

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

      function simplify(expression: any): any {
@@ -368,18 +464,7 @@ export class StaticReflector implements ReflectorReader {
          return result;
        }
        if (expression instanceof StaticSymbol) {
-          // Stop simplification at builtin symbols
-          if (expression === self.opaqueToken || self.conversionMap.has(expression)) {
-            return expression;
-          } else {
-            const staticSymbol = expression;
-            const declarationValue = resolveReferenceValue(staticSymbol);
-            if (declarationValue) {
-              return simplifyInContext(staticSymbol, declarationValue, depth + 1);
-            } else {
-              return staticSymbol;
-            }
-          }
+          return expression;
        }
        if (expression) {
          if (expression['__symbolic']) {
@@ -457,33 +542,43 @@ 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);
-                  selectContext =
-                      self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
-                  const declarationValue = resolveReferenceValue(selectContext);
-                  if (declarationValue) {
-                    return simplifyInContext(selectContext, declarationValue, depth + 1);
+                  // Access to a static instance variable
+                  const declarationValue = resolveReferenceValue(selectTarget);
+                  if (declarationValue && declarationValue.statics) {
+                    selectTarget = declarationValue.statics;
                  } else {
-                    return selectContext;
+                    const member: string = expression['member'];
+                    const members = selectTarget.members ?
+                        (selectTarget.members as string[]).concat(member) :
+                        [member];
+                    return _this.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
                  }
                }
-                if (selectTarget && isPrimitive(member))
-                  return simplifyInContext(selectContext, selectTarget[member], depth + 1);
+                const member = simplify(expression['member']);
+                if (selectTarget && isPrimitive(member)) return simplify(selectTarget[member]);
                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.module) {
+                  const name: string = expression['name'];
+                  const localValue = scope.resolve(name);
+                  if (localValue != BindingScope.missing) {
+                    return localValue;
+                  }
                }
-                break;
+                staticSymbol = resolveReference(context, expression);
+                let result: any = staticSymbol;
+                let declarationValue = resolveReferenceValue(result);
+                if (declarationValue) {
+                  if (isOpaqueToken(staticSymbol, declarationValue)) {
+                    // If the referenced symbol is initalized by a new OpaqueToken we can keep the
+                    // reference to the symbol.
+                    return staticSymbol;
+                  }
+                  result = simplifyInContext(staticSymbol, declarationValue, depth + 1);
+                }
+                return result;
              case 'class':
                return context;
              case 'function':
@@ -491,26 +586,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 =
+                      _this.findDeclaration(target['module'], target['name'], context.filePath);
+                } else {
+                  staticSymbol = _this.getStaticSymbol(context.filePath, target['name']);
                }
-                break;
+                let converter = _this.conversionMap.get(staticSymbol);
+                if (converter) {
+                  let args: any[] = expression['arguments'];
+                  if (!args) {
+                    args = [];
+                  }
+                  return converter(
+                      context, args.map(arg => simplifyInContext(context, arg, depth + 1)));
+                }
+
+                // Determine if the function is one we can simplify.
+                return simplifyCall(expression);
+
              case 'error':
                let message = produceErrorMessage(expression);
                if (expression['line']) {
@@ -531,9 +626,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);
        }
@@ -541,26 +634,45 @@ export class StaticReflector implements ReflectorReader {
      }
    }

-    const recordedSimplifyInContext = (context: StaticSymbol, value: any, depth: number) => {
-      try {
-        return simplifyInContext(context, value, depth);
-      } catch (e) {
-        this.reportError(e, context);
-      }
-    };
-
-    const result = this.errorRecorder ? recordedSimplifyInContext(context, value, 0) :
-                                        simplifyInContext(context, value, 0);
+    const result = simplifyInContext(context, value, 0);
    if (shouldIgnore(result)) {
      return undefined;
    }
    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) {
+        throw new Error(
+            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`);
+      }
+      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'};
  }
 }

@@ -605,11 +717,7 @@ function mapStringMap(input: {[key: string]: any}, transform: (value: any, key:
  Object.keys(input).forEach((key) => {
    const value = transform(input[key], key);
    if (!shouldIgnore(value)) {
-      if (HIDDEN_KEY.test(key)) {
-        Object.defineProperty(result, key, {enumerable: false, configurable: true, value: value});
-      } else {
-        result[key] = value;
-      }
+      result[key] = value;
    }
  });
  return result;
@@ -652,7 +760,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 {
@@ -6,6 +6,10 @@
 * found in the LICENSE file at https://angular.io/license
 */

+export function isStaticSymbol(value: any): value is StaticSymbol {
+  return typeof value === 'object' && value !== null && value['name'] && value['filePath'];
+}
+
 /**
 * A token representing the a reference to a static type.
 *
@@ -14,23 +18,3 @@
 export class StaticSymbol {
  constructor(public filePath: string, public name: string, public members?: string[]) {}
 }
-
-/**
- * A cache of static symbol used by the StaticReflector to return the same symbol for the
- * same symbol values.
- */
-export class StaticSymbolCache {
-  private cache = new Map<string, StaticSymbol>();
-
-  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    members = members || [];
-    const memberSuffix = members.length ? `.${ members.join('.')}` : '';
-    const key = `"${declarationFile}".${name}${memberSuffix}`;
-    let result = this.cache.get(key);
-    if (!result) {
-      result = new StaticSymbol(declarationFile, name, members);
-      this.cache.set(key, result);
-    }
-    return result;
-  }
-}
@@ -1,289 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-
-export class ResolvedStaticSymbol {
-  constructor(public symbol: StaticSymbol, public metadata: any) {}
-}
-
-/**
- * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other
- * language
- * services and from underlying file systems.
- */
-export interface StaticSymbolResolverHost {
-  /**
-   * Return a ModuleMetadata for the given module.
-   * Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
-   * produced and the module has exported variables or classes with decorators. Module metadata can
-   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
-   *
-   * @param modulePath is a string identifier for a module as an absolute path.
-   * @returns the metadata for the given module.
-   */
-  getMetadataFor(modulePath: string): {[key: string]: any}[];
-
-  /**
-   * Converts a module name that is used in an `import` to a file path.
-   * I.e.
-   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
-   */
-  moduleNameToFileName(moduleName: string, containingFile: string): string /*|null*/;
-}
-
-const SUPPORTED_SCHEMA_VERSION = 3;
-
-/**
- * This class is responsible for loading metadata per symbol,
- * and normalizing references between symbols.
- */
-export class StaticSymbolResolver {
-  private metadataCache = new Map<string, {[key: string]: any}>();
-  private resolvedSymbols = new Map<StaticSymbol, ResolvedStaticSymbol>();
-  private resolvedFilePaths = new Set<string>();
-
-  constructor(
-      private host: StaticSymbolResolverHost, private staticSymbolCache: StaticSymbolCache,
-      private summaryResolver: SummaryResolver<StaticSymbol>,
-      private errorRecorder?: (error: any, fileName: string) => void) {}
-
-  resolveSymbol(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    if (staticSymbol.members.length > 0) {
-      return this._resolveSymbolMembers(staticSymbol);
-    }
-    let result = this._resolveSymbolFromSummary(staticSymbol);
-    if (!result) {
-      // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
-      // have summaries, only .d.ts files. So we always need to check both, the summary
-      // and metadata.
-      this._createSymbolsOf(staticSymbol.filePath);
-      result = this.resolvedSymbols.get(staticSymbol);
-    }
-    return result;
-  }
-
-  private _resolveSymbolMembers(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    const members = staticSymbol.members;
-    const baseResolvedSymbol =
-        this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));
-    if (!baseResolvedSymbol) {
-      return null;
-    }
-    const baseMetadata = baseResolvedSymbol.metadata;
-    if (baseMetadata instanceof StaticSymbol) {
-      return new ResolvedStaticSymbol(
-          staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));
-    } else if (baseMetadata && baseMetadata.__symbolic === 'class') {
-      if (baseMetadata.statics && members.length === 1) {
-        return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);
-      }
-    } else {
-      let value = baseMetadata;
-      for (let i = 0; i < members.length && value; i++) {
-        value = value[members[i]];
-      }
-      return new ResolvedStaticSymbol(staticSymbol, value);
-    }
-    return null;
-  }
-
-  private _resolveSymbolFromSummary(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    const summary = this.summaryResolver.resolveSummary(staticSymbol);
-    return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;
-  }
-
-  /**
-   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
-   * All types passed to the StaticResolver should be pseudo-types returned by this method.
-   *
-   * @param declarationFile the absolute path of the file where the symbol is declared
-   * @param name the name of the type.
-   */
-  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.staticSymbolCache.get(declarationFile, name, members);
-  }
-
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
-    // have summaries, only .d.ts files. So we always need to check both, the summary
-    // and metadata.
-    let symbols = new Set<StaticSymbol>(this.summaryResolver.getSymbolsOf(filePath));
-    this._createSymbolsOf(filePath);
-    this.resolvedSymbols.forEach((resolvedSymbol) => {
-      if (resolvedSymbol.symbol.filePath === filePath) {
-        symbols.add(resolvedSymbol.symbol);
-      }
-    });
-    return Array.from(symbols);
-  }
-
-  private _createSymbolsOf(filePath: string) {
-    if (this.resolvedFilePaths.has(filePath)) {
-      return;
-    }
-    this.resolvedFilePaths.add(filePath);
-    const resolvedSymbols: ResolvedStaticSymbol[] = [];
-    const metadata = this.getModuleMetadata(filePath);
-    if (metadata['metadata']) {
-      // handle direct declarations of the symbol
-      Object.keys(metadata['metadata']).forEach((symbolName) => {
-        const symbolMeta = metadata['metadata'][symbolName];
-        resolvedSymbols.push(
-            this.createResolvedSymbol(this.getStaticSymbol(filePath, symbolName), symbolMeta));
-      });
-    }
-
-    // handle the symbols in one of the re-export location
-    if (metadata['exports']) {
-      for (const moduleExport of metadata['exports']) {
-        // handle the symbols in the list of explicitly re-exported symbols.
-        if (moduleExport.export) {
-          moduleExport.export.forEach((exportSymbol: any) => {
-            let symbolName: string;
-            if (typeof exportSymbol === 'string') {
-              symbolName = exportSymbol;
-            } else {
-              symbolName = exportSymbol.as;
-            }
-            let symName = symbolName;
-            if (typeof exportSymbol !== 'string') {
-              symName = exportSymbol.name;
-            }
-            const resolvedModule = this.resolveModule(moduleExport.from, filePath);
-            if (resolvedModule) {
-              const targetSymbol = this.getStaticSymbol(resolvedModule, symName);
-              const sourceSymbol = this.getStaticSymbol(filePath, symbolName);
-              resolvedSymbols.push(new ResolvedStaticSymbol(sourceSymbol, targetSymbol));
-            }
-          });
-        } else {
-          // handle the symbols via export * directives.
-          const resolvedModule = this.resolveModule(moduleExport.from, filePath);
-          if (resolvedModule) {
-            const nestedExports = this.getSymbolsOf(resolvedModule);
-            nestedExports.forEach((targetSymbol) => {
-              const sourceSymbol = this.getStaticSymbol(filePath, targetSymbol.name);
-              resolvedSymbols.push(new ResolvedStaticSymbol(sourceSymbol, targetSymbol));
-            });
-          }
-        }
-      }
-    }
-    resolvedSymbols.forEach(
-        (resolvedSymbol) => this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol));
-  }
-
-  private createResolvedSymbol(sourceSymbol: StaticSymbol, metadata: any): ResolvedStaticSymbol {
-    const self = this;
-
-    class ReferenceTransformer extends ValueTransformer {
-      visitStringMap(map: {[key: string]: any}, functionParams: string[]): any {
-        const symbolic = map['__symbolic'];
-        if (symbolic === 'function') {
-          const oldLen = functionParams.length;
-          functionParams.push(...(map['parameters'] || []));
-          const result = super.visitStringMap(map, functionParams);
-          functionParams.length = oldLen;
-          return result;
-        } else if (symbolic === 'reference') {
-          const module = map['module'];
-          const name = map['name'];
-          if (!name) {
-            return null;
-          }
-          let filePath: string;
-          if (module) {
-            filePath = self.resolveModule(module, sourceSymbol.filePath);
-            if (!filePath) {
-              return {
-                __symbolic: 'error',
-                message: `Could not resolve ${module} relative to ${sourceSymbol.filePath}.`
-              };
-            }
-          } else {
-            const isFunctionParam = functionParams.indexOf(name) >= 0;
-            if (!isFunctionParam) {
-              filePath = sourceSymbol.filePath;
-            }
-          }
-          if (filePath) {
-            return self.getStaticSymbol(filePath, name);
-          } else {
-            // reference to a function parameter
-            return {__symbolic: 'reference', name: name};
-          }
-        } else {
-          return super.visitStringMap(map, functionParams);
-        }
-      }
-    }
-
-    const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);
-    return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
-  }
-
-  private reportError(error: Error, context: StaticSymbol, path?: string) {
-    if (this.errorRecorder) {
-      this.errorRecorder(error, (context && context.filePath) || path);
-    } else {
-      throw error;
-    }
-  }
-
-  /**
-   * @param module an absolute path to a module file.
-   */
-  private getModuleMetadata(module: string): {[key: string]: any} {
-    let moduleMetadata = this.metadataCache.get(module);
-    if (!moduleMetadata) {
-      const moduleMetadatas = this.host.getMetadataFor(module);
-      if (moduleMetadatas) {
-        let maxVersion = -1;
-        moduleMetadatas.forEach((md) => {
-          if (md['version'] > maxVersion) {
-            maxVersion = md['version'];
-            moduleMetadata = md;
-          }
-        });
-      }
-      if (!moduleMetadata) {
-        moduleMetadata =
-            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
-      }
-      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
-        const errorMessage = moduleMetadata['version'] == 2 ?
-            `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
-            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
-        this.reportError(new Error(errorMessage), null);
-      }
-      this.metadataCache.set(module, moduleMetadata);
-    }
-    return moduleMetadata;
-  }
-
-  getSymbolByModule(module: string, symbolName: string, containingFile?: string): StaticSymbol {
-    const filePath = this.resolveModule(module, containingFile);
-    if (!filePath) {
-      throw new Error(`Could not resolve module ${module} relative to ${containingFile}`);
-    }
-    return this.getStaticSymbol(filePath, symbolName);
-  }
-
-  private resolveModule(module: string, containingFile: string): string {
-    try {
-      return this.host.moduleNameToFileName(module, containingFile);
-    } catch (e) {
-      console.error(`Could not resolve module '${module}' relative to file ${containingFile}`);
-      this.reportError(new e, null, containingFile);
-    }
-  }
-}
@@ -1,77 +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 {CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
-
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol} from './static_symbol_resolver';
-import {deserializeSummaries, summaryFileName} from './summary_serializer';
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export interface AotSummaryResolverHost {
-  /**
-   * Loads an NgModule/Directive/Pipe summary file
-   */
-  loadSummary(filePath: string): string /*|null*/;
-
-  /**
-   * Returns whether a file is a source file or not.
-   */
-  isSourceFile(sourceFilePath: string): boolean;
-}
-
-export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
-  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
-  private loadedFilePaths = new Set<string>();
-
-  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
-
-  private _assertNoMembers(symbol: StaticSymbol) {
-    if (symbol.members.length) {
-      throw new Error(
-          `Internal state: StaticSymbols in summaries can't have members! ${JSON.stringify(symbol)}`);
-    }
-  }
-
-  resolveSummary(staticSymbol: StaticSymbol): Summary<StaticSymbol> {
-    this._assertNoMembers(staticSymbol);
-    let summary = this.summaryCache.get(staticSymbol);
-    if (!summary) {
-      this._loadSummaryFile(staticSymbol.filePath);
-      summary = this.summaryCache.get(staticSymbol);
-    }
-    return summary;
-  }
-
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    this._loadSummaryFile(filePath);
-    return Array.from(this.summaryCache.keys()).filter((symbol) => symbol.filePath === filePath);
-  }
-
-  private _loadSummaryFile(filePath: string) {
-    if (this.loadedFilePaths.has(filePath)) {
-      return;
-    }
-    this.loadedFilePaths.add(filePath);
-    if (!this.host.isSourceFile(filePath)) {
-      const summaryFilePath = summaryFileName(filePath);
-      let json: string;
-      try {
-        json = this.host.loadSummary(summaryFilePath);
-      } catch (e) {
-        console.error(`Error loading summary file ${summaryFilePath}`);
-        throw e;
-      }
-      if (json) {
-        const readSummaries = deserializeSummaries(this.staticSymbolCache, json);
-        readSummaries.forEach((summary) => { this.summaryCache.set(summary.symbol, summary); });
-      }
-    }
-  }
-}
@@ -1,183 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {GeneratedFile} from './generated_file';
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export interface AotSummarySerializerHost {
-  /**
-   * Returns the output file path of a source file.
-   * E.g.
-   * `some_file.ts` -> `some_file.d.ts`
-   */
-  getOutputFileName(sourceFilePath: string): string;
-  /**
-   * Returns whether a file is a source file or not.
-   */
-  isSourceFile(sourceFilePath: string): boolean;
-}
-
-export function serializeSummaries(
-    host: AotSummarySerializerHost, summaryResolver: SummaryResolver<StaticSymbol>,
-    symbolResolver: StaticSymbolResolver,
-
-    symbols: ResolvedStaticSymbol[], types: CompileTypeSummary[]): string {
-  const serializer = new Serializer(host);
-
-  // for symbols, we use everything except for the class metadata itself
-  // (we keep the statics though), as the class metadata is contained in the
-  // CompileTypeSummary.
-  symbols.forEach(
-      (resolvedSymbol) => serializer.addOrMergeSummary(
-          {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata}));
-  // Add summaries that are referenced by the given symbols (transitively)
-  // Note: the serializer.symbols array might be growing while
-  // we execute the loop!
-  for (let processedIndex = 0; processedIndex < serializer.symbols.length; processedIndex++) {
-    const symbol = serializer.symbols[processedIndex];
-    if (!host.isSourceFile(symbol.filePath)) {
-      let summary = summaryResolver.resolveSummary(symbol);
-      if (!summary) {
-        // some symbols might originate from a plain typescript library
-        // that just exported .d.ts and .metadata.json files, i.e. where no summary
-        // files were created.
-        const resolvedSymbol = symbolResolver.resolveSymbol(symbol);
-        if (resolvedSymbol) {
-          summary = {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata};
-        }
-      }
-      if (summary) {
-        serializer.addOrMergeSummary(summary);
-      }
-    }
-  }
-
-  // Add type summaries.
-  // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,
-  // as the type summaries already contain the transitive data that they require
-  // (in a minimal way).
-  types.forEach((typeSummary) => {
-    serializer.addOrMergeSummary(
-        {symbol: typeSummary.type.reference, metadata: {__symbolic: 'class'}, type: typeSummary});
-    if (typeSummary.summaryKind === CompileSummaryKind.NgModule) {
-      const ngModuleSummary = <CompileNgModuleSummary>typeSummary;
-      ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach((id) => {
-        const symbol: StaticSymbol = id.reference;
-        if (!host.isSourceFile(symbol.filePath)) {
-          serializer.addOrMergeSummary(summaryResolver.resolveSummary(symbol));
-        }
-      });
-    }
-  });
-  return serializer.serialize();
-}
-
-export function deserializeSummaries(
-    symbolCache: StaticSymbolCache, json: string): Summary<StaticSymbol>[] {
-  const deserializer = new Deserializer(symbolCache);
-  return deserializer.deserialize(json);
-}
-
-export function summaryFileName(fileName: string): string {
-  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
-  return `${fileNameWithoutSuffix}.ngsummary.json`;
-}
-
-class Serializer extends ValueTransformer {
-  symbols: StaticSymbol[] = [];
-  private indexBySymbol = new Map<StaticSymbol, number>();
-  // This now contains a `__symbol: number` in the place of
-  // StaticSymbols, but otherwise has the same shape as the original objects.
-  private processedSummaryBySymbol = new Map<StaticSymbol, any>();
-  private processedSummaries: any[] = [];
-
-  constructor(private host: AotSummarySerializerHost) { super(); }
-
-  addOrMergeSummary(summary: Summary<StaticSymbol>) {
-    let symbolMeta = summary.metadata;
-    if (symbolMeta && symbolMeta.__symbolic === 'class') {
-      // For classes, we only keep their statics, but not the metadata
-      // of the class itself as that has been captured already via other summaries
-      // (e.g. DirectiveSummary, ...).
-      symbolMeta = {__symbolic: 'class', statics: symbolMeta.statics};
-    }
-
-    let processedSummary = this.processedSummaryBySymbol.get(summary.symbol);
-    if (!processedSummary) {
-      processedSummary = this.processValue({symbol: summary.symbol});
-      this.processedSummaries.push(processedSummary);
-      this.processedSummaryBySymbol.set(summary.symbol, processedSummary);
-    }
-    // Note: == by purpose to compare with undefined!
-    if (processedSummary.metadata == null && symbolMeta != null) {
-      processedSummary.metadata = this.processValue(symbolMeta);
-    }
-    // Note: == by purpose to compare with undefined!
-    if (processedSummary.type == null && summary.type != null) {
-      processedSummary.type = this.processValue(summary.type);
-    }
-  }
-
-  serialize(): string {
-    return JSON.stringify({
-      summaries: this.processedSummaries,
-      symbols: this.symbols.map((symbol, index) => {
-        return {
-          __symbol: index,
-          name: symbol.name,
-          // We convert the source filenames tinto output filenames,
-          // as the generated summary file will be used when teh current
-          // compilation unit is used as a library
-          filePath: this.host.getOutputFileName(symbol.filePath)
-        };
-      })
-    });
-  }
-
-  private processValue(value: any): any { return visitValue(value, this, null); }
-
-  visitOther(value: any, context: any): any {
-    if (value instanceof StaticSymbol) {
-      let index = this.indexBySymbol.get(value);
-      // Note: == by purpose to compare with undefined!
-      if (index == null) {
-        index = this.indexBySymbol.size;
-        this.indexBySymbol.set(value, index);
-        this.symbols.push(value);
-      }
-      return {__symbol: index};
-    }
-  }
-}
-
-class Deserializer extends ValueTransformer {
-  private symbols: StaticSymbol[];
-
-  constructor(private symbolCache: StaticSymbolCache) { super(); }
-
-  deserialize(json: string): Summary<StaticSymbol>[] {
-    const data: {summaries: any[], symbols: any[]} = JSON.parse(json);
-    this.symbols = data.symbols.map(
-        serializedSymbol => this.symbolCache.get(serializedSymbol.filePath, serializedSymbol.name));
-    return visitValue(data.summaries, this, null);
-  }
-
-  visitStringMap(map: {[key: string]: any}, context: any): any {
-    if ('__symbol' in map) {
-      return this.symbols[map['__symbol']];
-    } else {
-      return super.visitStringMap(map, context);
-    }
-  }
-}
@@ -8,12 +8,11 @@

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

-import {StaticSymbol} from './aot/static_symbol';
 import {ListWrapper} from './facade/collection';
-import {isPresent, stringify} from './facade/lang';
-import {LifecycleHooks, reflector} from './private_import_core';
+import {isPresent} from './facade/lang';
+import {LifecycleHooks} from './private_import_core';
 import {CssSelector} from './selector';
-import {splitAtColon} from './util';
+import {sanitizeIdentifier, splitAtColon} from './util';

 function unimplemented(): any {
  throw new Error('unimplemented');
@@ -25,6 +24,10 @@ function unimplemented(): any {
 // group 3: "@trigger" from "@trigger"
 const HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/;

+export abstract class CompileMetadataWithIdentifier {
+  get identifier(): CompileIdentifierMetadata { return <CompileIdentifierMetadata>unimplemented(); }
+}
+
 export class CompileAnimationEntryMetadata {
  constructor(
      public name: string = null, public definitions: CompileAnimationStateMetadata[] = null) {}
@@ -75,50 +78,24 @@ export class CompileAnimationGroupMetadata extends CompileAnimationWithStepsMeta
  constructor(steps: CompileAnimationMetadata[] = null) { super(steps); }
 }

+export class CompileIdentifierMetadata implements CompileMetadataWithIdentifier {
+  reference: any;
+  name: string;
+  prefix: string;
+  moduleUrl: string;
+  value: any;

-function _sanitizeIdentifier(name: string): string {
-  return name.replace(/\W/g, '_');
-}
-
-let _anonymousTypeIndex = 0;
-
-export function identifierName(compileIdentifier: CompileIdentifierMetadata): string {
-  if (!compileIdentifier || !compileIdentifier.reference) {
-    return null;
+  constructor(
+      {reference, name, moduleUrl, prefix, value}:
+          {reference?: any, name?: string, moduleUrl?: string, prefix?: string, value?: any} = {}) {
+    this.reference = reference;
+    this.name = name;
+    this.prefix = prefix;
+    this.moduleUrl = moduleUrl;
+    this.value = value;
  }
-  const ref = compileIdentifier.reference;
-  if (ref instanceof StaticSymbol) {
-    return ref.name;
-  }
-  if (ref['__anonymousType']) {
-    return ref['__anonymousType'];
-  }
-  let identifier = stringify(ref);
-  if (identifier.indexOf('(') >= 0) {
-    // case: anonymous functions!
-    identifier = `anonymous_${_anonymousTypeIndex++}`;
-    ref['__anonymousType'] = identifier;
-  } else {
-    identifier = _sanitizeIdentifier(identifier);
-  }
-  return identifier;
-}

-export function identifierModuleUrl(compileIdentifier: CompileIdentifierMetadata): string {
-  const ref = compileIdentifier.reference;
-  if (ref instanceof StaticSymbol) {
-    return ref.filePath;
-  }
-  return reflector.importUri(ref);
-}
-
-export interface CompileIdentifierMetadata { reference: any; }
-
-export enum CompileSummaryKind {
-  Pipe,
-  Directive,
-  NgModule,
-  Injectable
+  get identifier(): CompileIdentifierMetadata { return this; }
 }

 /**
@@ -126,70 +103,158 @@ 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 {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
 }

-export interface CompileDiDependencyMetadata {
-  isAttribute?: boolean;
-  isSelf?: boolean;
-  isHost?: boolean;
-  isSkipSelf?: boolean;
-  isOptional?: boolean;
-  isValue?: boolean;
-  token?: CompileTokenMetadata;
-  value?: any;
-}
-
-export interface CompileProviderMetadata {
+export class CompileDiDependencyMetadata {
+  isAttribute: boolean;
+  isSelf: boolean;
+  isHost: boolean;
+  isSkipSelf: boolean;
+  isOptional: boolean;
+  isValue: boolean;
  token: CompileTokenMetadata;
-  useClass?: CompileTypeMetadata;
-  useValue?: any;
-  useExisting?: CompileTokenMetadata;
-  useFactory?: CompileFactoryMetadata;
-  deps?: CompileDiDependencyMetadata[];
-  multi?: boolean;
-}
+  value: any;

-export interface CompileFactoryMetadata extends CompileIdentifierMetadata {
-  diDeps: CompileDiDependencyMetadata[];
-  reference: any;
-}
-
-export function tokenName(token: CompileTokenMetadata) {
-  return isPresent(token.value) ? _sanitizeIdentifier(token.value) :
-                                  identifierName(token.identifier);
-}
-
-export function tokenReference(token: CompileTokenMetadata) {
-  if (isPresent(token.identifier)) {
-    return token.identifier.reference;
-  } else {
-    return token.value;
+  constructor({isAttribute, isSelf, isHost, isSkipSelf, isOptional, isValue, token, value}: {
+    isAttribute?: boolean,
+    isSelf?: boolean,
+    isHost?: boolean,
+    isSkipSelf?: boolean,
+    isOptional?: boolean,
+    isValue?: boolean,
+    query?: CompileQueryMetadata,
+    viewQuery?: CompileQueryMetadata,
+    token?: CompileTokenMetadata,
+    value?: any
+  } = {}) {
+    this.isAttribute = !!isAttribute;
+    this.isSelf = !!isSelf;
+    this.isHost = !!isHost;
+    this.isSkipSelf = !!isSkipSelf;
+    this.isOptional = !!isOptional;
+    this.isValue = !!isValue;
+    this.token = token;
+    this.value = value;
  }
 }

-export interface CompileTokenMetadata {
-  value?: any;
-  identifier?: CompileIdentifierMetadata|CompileTypeMetadata;
+export class CompileProviderMetadata {
+  token: CompileTokenMetadata;
+  useClass: CompileTypeMetadata;
+  useValue: any;
+  useExisting: CompileTokenMetadata;
+  useFactory: CompileFactoryMetadata;
+  deps: CompileDiDependencyMetadata[];
+  multi: boolean;
+
+  constructor({token, useClass, useValue, useExisting, useFactory, deps, multi}: {
+    token?: CompileTokenMetadata,
+    useClass?: CompileTypeMetadata,
+    useValue?: any,
+    useExisting?: CompileTokenMetadata,
+    useFactory?: CompileFactoryMetadata,
+    deps?: CompileDiDependencyMetadata[],
+    multi?: boolean
+  }) {
+    this.token = token;
+    this.useClass = useClass;
+    this.useValue = useValue;
+    this.useExisting = useExisting;
+    this.useFactory = useFactory;
+    this.deps = deps || null;
+    this.multi = !!multi;
+  }
+}
+
+export class CompileFactoryMetadata extends CompileIdentifierMetadata {
+  diDeps: CompileDiDependencyMetadata[];
+
+  constructor({reference, name, moduleUrl, prefix, diDeps, value}: {
+    reference?: Function,
+    name?: string,
+    prefix?: string,
+    moduleUrl?: string,
+    value?: boolean,
+    diDeps?: CompileDiDependencyMetadata[]
+  }) {
+    super({reference: reference, name: name, prefix: prefix, moduleUrl: moduleUrl, value: value});
+    this.diDeps = _normalizeArray(diDeps);
+  }
+}
+
+export class CompileTokenMetadata implements CompileMetadataWithIdentifier {
+  value: any;
+  identifier: CompileIdentifierMetadata;
+  identifierIsInstance: boolean;
+
+  constructor(
+      {value, identifier, identifierIsInstance}:
+          {value?: any, identifier?: CompileIdentifierMetadata, identifierIsInstance?: boolean}) {
+    this.value = value;
+    this.identifier = identifier;
+    this.identifierIsInstance = !!identifierIsInstance;
+  }
+
+  get reference(): any {
+    if (isPresent(this.identifier)) {
+      return this.identifier.reference;
+    } else {
+      return this.value;
+    }
+  }
+
+  get name(): string {
+    return isPresent(this.value) ? sanitizeIdentifier(this.value) : this.identifier.name;
+  }
 }

 /**
 * Metadata regarding compilation of a type.
 */
-export interface CompileTypeMetadata extends CompileIdentifierMetadata {
+export class CompileTypeMetadata extends CompileIdentifierMetadata {
+  isHost: boolean;
  diDeps: CompileDiDependencyMetadata[];
  lifecycleHooks: LifecycleHooks[];
-  reference: any;
+
+  constructor({reference, name, moduleUrl, prefix, isHost, value, diDeps, lifecycleHooks}: {
+    reference?: Type<any>,
+    name?: string,
+    moduleUrl?: string,
+    prefix?: string,
+    isHost?: boolean,
+    value?: any,
+    diDeps?: CompileDiDependencyMetadata[],
+    lifecycleHooks?: LifecycleHooks[];
+  } = {}) {
+    super({reference: reference, name: name, moduleUrl: moduleUrl, prefix: prefix, value: value});
+    this.isHost = !!isHost;
+    this.diDeps = _normalizeArray(diDeps);
+    this.lifecycleHooks = _normalizeArray(lifecycleHooks);
+  }
 }

-export interface CompileQueryMetadata {
+export class CompileQueryMetadata {
  selectors: Array<CompileTokenMetadata>;
  descendants: boolean;
  first: boolean;
  propertyName: string;
  read: CompileTokenMetadata;
+
+  constructor({selectors, descendants, first, propertyName, read}: {
+    selectors?: Array<CompileTokenMetadata>,
+    descendants?: boolean,
+    first?: boolean,
+    propertyName?: string,
+    read?: CompileTokenMetadata
+  } = {}) {
+    this.selectors = selectors;
+    this.descendants = !!descendants;
+    this.first = !!first;
+    this.propertyName = propertyName;
+    this.read = read;
+  }
 }

 /**
@@ -211,7 +276,8 @@ export class CompileStylesheetMetadata {
 /**
 * Summary Metadata regarding compilation of a template.
 */
-export interface CompileTemplateSummary {
+export interface CompileTemplateSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
  animations: string[];
  ngContentSelectors: string[];
  encapsulation: ViewEncapsulation;
@@ -259,6 +325,7 @@ export class CompileTemplateMetadata {

  toSummary(): CompileTemplateSummary {
    return {
+      isSummary: true,
      animations: this.animations.map(anim => anim.name),
      ngContentSelectors: this.ngContentSelectors,
      encapsulation: this.encapsulation
@@ -266,9 +333,8 @@ export class CompileTemplateMetadata {
  }
 }

-// 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 {
+export interface CompileDirectiveSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
  type: CompileTypeMetadata;
  isComponent: boolean;
  selector: string;
@@ -289,11 +355,10 @@ export interface CompileDirectiveSummary extends CompileTypeSummary {
 /**
 * Metadata regarding compilation of a directive.
 */
-export class CompileDirectiveMetadata {
+export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
  static create(
-      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host,
-       providers, viewProviders, queries, viewQueries, entryComponents, template}: {
-        isHost?: boolean,
+      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host, providers,
+       viewProviders, queries, viewQueries, entryComponents, template}: {
        type?: CompileTypeMetadata,
        isComponent?: boolean,
        selector?: string,
@@ -302,8 +367,10 @@ export class CompileDirectiveMetadata {
        inputs?: string[],
        outputs?: string[],
        host?: {[key: string]: string},
-        providers?: CompileProviderMetadata[],
-        viewProviders?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        viewProviders?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
        queries?: CompileQueryMetadata[],
        viewQueries?: CompileQueryMetadata[],
        entryComponents?: CompileIdentifierMetadata[],
@@ -345,7 +412,6 @@ export class CompileDirectiveMetadata {
    }

    return new CompileDirectiveMetadata({
-      isHost,
      type,
      isComponent: !!isComponent, selector, exportAs, changeDetection,
      inputs: inputsMap,
@@ -361,7 +427,6 @@ export class CompileDirectiveMetadata {
      template,
    });
  }
-  isHost: boolean;
  type: CompileTypeMetadata;
  isComponent: boolean;
  selector: string;
@@ -381,10 +446,9 @@ export class CompileDirectiveMetadata {
  template: CompileTemplateMetadata;

  constructor(
-      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
-       hostListeners, hostProperties, hostAttributes, providers, viewProviders, queries,
-       viewQueries, entryComponents, template}: {
-        isHost?: boolean,
+      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, hostListeners,
+       hostProperties, hostAttributes, providers, viewProviders, queries, viewQueries,
+       entryComponents, template}: {
        type?: CompileTypeMetadata,
        isComponent?: boolean,
        selector?: string,
@@ -395,14 +459,15 @@ export class CompileDirectiveMetadata {
        hostListeners?: {[key: string]: string},
        hostProperties?: {[key: string]: string},
        hostAttributes?: {[key: string]: string},
-        providers?: CompileProviderMetadata[],
-        viewProviders?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        viewProviders?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
        queries?: CompileQueryMetadata[],
        viewQueries?: CompileQueryMetadata[],
        entryComponents?: CompileIdentifierMetadata[],
        template?: CompileTemplateMetadata,
      } = {}) {
-    this.isHost = !!isHost;
    this.type = type;
    this.isComponent = isComponent;
    this.selector = selector;
@@ -422,9 +487,11 @@ export class CompileDirectiveMetadata {
    this.template = template;
  }

+  get identifier(): CompileIdentifierMetadata { return this.type; }
+
  toSummary(): CompileDirectiveSummary {
    return {
-      summaryKind: CompileSummaryKind.Directive,
+      isSummary: true,
      type: this.type,
      isComponent: this.isComponent,
      selector: this.selector,
@@ -447,12 +514,16 @@ export class CompileDirectiveMetadata {
 /**
 * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
 */
-export function createHostComponentMeta(
-    typeReference: any, compMeta: CompileDirectiveMetadata): CompileDirectiveMetadata {
+export function createHostComponentMeta(compMeta: CompileDirectiveMetadata):
+    CompileDirectiveMetadata {
  const template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate();
  return CompileDirectiveMetadata.create({
-    isHost: true,
-    type: {reference: typeReference, diDeps: [], lifecycleHooks: []},
+    type: new CompileTypeMetadata({
+      reference: Object,
+      name: `${compMeta.type.name}_Host`,
+      moduleUrl: compMeta.type.moduleUrl,
+      isHost: true
+    }),
    template: new CompileTemplateMetadata({
      encapsulation: ViewEncapsulation.None,
      template: template,
@@ -475,13 +546,14 @@ export function createHostComponentMeta(
  });
 }

-export interface CompilePipeSummary extends CompileTypeSummary {
+export interface CompilePipeSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
  type: CompileTypeMetadata;
  name: string;
  pure: boolean;
 }

-export class CompilePipeMetadata {
+export class CompilePipeMetadata implements CompileMetadataWithIdentifier {
  type: CompileTypeMetadata;
  name: string;
  pure: boolean;
@@ -495,44 +567,42 @@ export class CompilePipeMetadata {
    this.name = name;
    this.pure = !!pure;
  }
+  get identifier(): CompileIdentifierMetadata { return this.type; }

  toSummary(): CompilePipeSummary {
-    return {
-      summaryKind: CompileSummaryKind.Pipe,
-      type: this.type,
-      name: this.name,
-      pure: this.pure
-    };
+    return {isSummary: true, type: this.type, name: this.name, pure: this.pure};
  }
 }

-// Note: This should only use interfaces as nested data types
-// as we need to be able to serialize this from/to JSON!
-export interface CompileNgModuleSummary extends CompileTypeSummary {
+export interface CompileNgModuleInjectorSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
  type: CompileTypeMetadata;
-
-  // Note: This is transitive over the exported modules.
-  exportedDirectives: CompileIdentifierMetadata[];
-  // Note: This is transitive over the exported modules.
-  exportedPipes: CompileIdentifierMetadata[];
-
-  // Note: This is transitive.
  entryComponents: CompileIdentifierMetadata[];
-  // Note: This is transitive.
-  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[];
-  // Note: This is transitive.
-  modules: CompileTypeMetadata[];
+  providers: CompileProviderMetadata[];
+  importedModules: CompileNgModuleInjectorSummary[];
+  exportedModules: CompileNgModuleInjectorSummary[];
 }

+export interface CompileNgModuleDirectiveSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+  type: CompileTypeMetadata;
+  exportedDirectives: CompileIdentifierMetadata[];
+  exportedPipes: CompileIdentifierMetadata[];
+  exportedModules: CompileNgModuleDirectiveSummary[];
+  directiveLoaders: (() => Promise<void>)[];
+}
+
+export type CompileNgModuleSummary =
+    CompileNgModuleInjectorSummary & CompileNgModuleDirectiveSummary;
+
 /**
 * Metadata regarding compilation of a module.
 */
-export class CompileNgModuleMetadata {
+export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
  type: CompileTypeMetadata;
  declaredDirectives: CompileIdentifierMetadata[];
  exportedDirectives: CompileIdentifierMetadata[];
  declaredPipes: CompileIdentifierMetadata[];
-
  exportedPipes: CompileIdentifierMetadata[];
  entryComponents: CompileIdentifierMetadata[];
  bootstrapComponents: CompileIdentifierMetadata[];
@@ -550,7 +620,8 @@ export class CompileNgModuleMetadata {
       entryComponents, bootstrapComponents, importedModules, exportedModules, schemas,
       transitiveModule, id}: {
        type?: CompileTypeMetadata,
-        providers?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
        declaredDirectives?: CompileIdentifierMetadata[],
        exportedDirectives?: CompileIdentifierMetadata[],
        declaredPipes?: CompileIdentifierMetadata[],
@@ -578,75 +649,69 @@ export class CompileNgModuleMetadata {
    this.transitiveModule = transitiveModule;
  }

+  get identifier(): CompileIdentifierMetadata { return this.type; }
+
  toSummary(): CompileNgModuleSummary {
    return {
-      summaryKind: CompileSummaryKind.NgModule,
+      isSummary: true,
      type: this.type,
-      entryComponents: this.transitiveModule.entryComponents,
-      providers: this.transitiveModule.providers,
-      modules: this.transitiveModule.modules,
-      exportedDirectives: this.transitiveModule.exportedDirectives,
-      exportedPipes: this.transitiveModule.exportedPipes
+      entryComponents: this.entryComponents,
+      providers: this.providers,
+      importedModules: this.importedModules,
+      exportedModules: this.exportedModules,
+      exportedDirectives: this.exportedDirectives,
+      exportedPipes: this.exportedPipes,
+      directiveLoaders: this.transitiveModule.directiveLoaders
+    };
+  }
+
+  toInjectorSummary(): CompileNgModuleInjectorSummary {
+    return {
+      isSummary: true,
+      type: this.type,
+      entryComponents: this.entryComponents,
+      providers: this.providers,
+      importedModules: this.importedModules,
+      exportedModules: this.exportedModules
+    };
+  }
+  toDirectiveSummary(): CompileNgModuleDirectiveSummary {
+    return {
+      isSummary: true,
+      type: this.type,
+      exportedDirectives: this.exportedDirectives,
+      exportedPipes: this.exportedPipes,
+      exportedModules: this.exportedModules,
+      directiveLoaders: this.transitiveModule.directiveLoaders
    };
  }
 }

 export class TransitiveCompileNgModuleMetadata {
  directivesSet = new Set<any>();
-  directives: CompileIdentifierMetadata[] = [];
-  exportedDirectivesSet = new Set<any>();
-  exportedDirectives: CompileIdentifierMetadata[] = [];
  pipesSet = new Set<any>();
-  pipes: CompileIdentifierMetadata[] = [];
-  exportedPipesSet = new Set<any>();
-  exportedPipes: CompileIdentifierMetadata[] = [];
-  modulesSet = new Set<any>();
-  modules: CompileTypeMetadata[] = [];
-  entryComponentsSet = new Set<any>();
-  entryComponents: CompileIdentifierMetadata[] = [];

-  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[] = [];
+  constructor(
+      public modules: CompileNgModuleInjectorSummary[], public providers: CompileProviderMetadata[],
+      public entryComponents: CompileIdentifierMetadata[],
+      public directives: CompileIdentifierMetadata[], public pipes: CompileIdentifierMetadata[],
+      public directiveLoaders: (() => Promise<void>)[]) {
+    directives.forEach(dir => this.directivesSet.add(dir.reference));
+    pipes.forEach(pipe => this.pipesSet.add(pipe.reference));
+  }
+}

-  addProvider(provider: CompileProviderMetadata, module: CompileIdentifierMetadata) {
-    this.providers.push({provider: provider, module: module});
-  }
+export function removeIdentifierDuplicates<T extends CompileMetadataWithIdentifier>(items: T[]):
+    T[] {
+  const map = new Map<any, T>();

-  addDirective(id: CompileIdentifierMetadata) {
-    if (!this.directivesSet.has(id.reference)) {
-      this.directivesSet.add(id.reference);
-      this.directives.push(id);
+  items.forEach((item) => {
+    if (!map.get(item.identifier.reference)) {
+      map.set(item.identifier.reference, item);
    }
-  }
-  addExportedDirective(id: CompileIdentifierMetadata) {
-    if (!this.exportedDirectivesSet.has(id.reference)) {
-      this.exportedDirectivesSet.add(id.reference);
-      this.exportedDirectives.push(id);
-    }
-  }
-  addPipe(id: CompileIdentifierMetadata) {
-    if (!this.pipesSet.has(id.reference)) {
-      this.pipesSet.add(id.reference);
-      this.pipes.push(id);
-    }
-  }
-  addExportedPipe(id: CompileIdentifierMetadata) {
-    if (!this.exportedPipesSet.has(id.reference)) {
-      this.exportedPipesSet.add(id.reference);
-      this.exportedPipes.push(id);
-    }
-  }
-  addModule(id: CompileTypeMetadata) {
-    if (!this.modulesSet.has(id.reference)) {
-      this.modulesSet.add(id.reference);
-      this.modules.push(id);
-    }
-  }
-  addEntryComponent(id: CompileIdentifierMetadata) {
-    if (!this.entryComponentsSet.has(id.reference)) {
-      this.entryComponentsSet.add(id.reference);
-      this.entryComponents.push(id);
-    }
-  }
+  });
+
+  return Array.from(map.values());
 }

 function _normalizeArray(obj: any[]): any[] {
@@ -6,7 +6,7 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Identifiers, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';

@@ -22,7 +22,7 @@ export function createCheckBindingField(builder: ClassBuilder): CheckBindingFiel
  // 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.importExpr(createIdentifier(Identifiers.UNINITIALIZED)))
+                             .set(o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED)))
                             .toStmt());
  return new CheckBindingField(fieldExpr, bindingId);
 }
@@ -30,7 +30,7 @@ export function createCheckBindingField(builder: ClassBuilder): CheckBindingFiel
 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([
+  let condition: o.Expression = o.importExpr(resolveIdentifier(Identifiers.checkBinding)).callFn([
    throwOnChangeVar, fieldExpr, evalResult.currValExpr
  ]);
  if (evalResult.forceUpdate) {
@@ -9,7 +9,7 @@

 import * as cdAst from '../expression_parser/ast';
 import {isBlank, isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';

@@ -116,7 +116,7 @@ export function createSharedBindingVariablesIfNeeded(stmts: o.Statement[]): o.St
  if (readVars.has(VAL_UNWRAPPER_VAR.name)) {
    unwrapperStmts.push(
        VAL_UNWRAPPER_VAR
-            .set(o.importExpr(createIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
+            .set(o.importExpr(resolveIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
            .toDeclStmt(null, [o.StmtModifier.Final]));
  }
  return unwrapperStmts;
@@ -277,20 +277,15 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
    args.push(o.literal(ast.strings[ast.strings.length - 1]));

    return ast.expressions.length <= 9 ?
-        o.importExpr(createIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
-        o.importExpr(createIdentifier(Identifiers.interpolate)).callFn([
+        o.importExpr(resolveIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
+        o.importExpr(resolveIdentifier(Identifiers.interpolate)).callFn([
          args[0], o.literalArr(args.slice(1))
        ]);
  }

  visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {
-    const leftMostSafe = this.leftMostSafeNode(ast);
-    if (leftMostSafe) {
-      return this.convertSafeAccess(ast, leftMostSafe, mode);
-    } else {
-      return convertToStatementIfNeeded(
-          mode, this.visit(ast.obj, _Mode.Expression).key(this.visit(ast.key, _Mode.Expression)));
-    }
+    return convertToStatementIfNeeded(
+        mode, this.visit(ast.obj, _Mode.Expression).key(this.visit(ast.key, _Mode.Expression)));
  }

  visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {
@@ -583,7 +578,7 @@ function flattenStatements(arg: any, output: o.Statement[]) {

 function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[]): o.Expression {
  if (values.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_ARRAY));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_ARRAY));
  }
  const proxyExpr = o.THIS_EXPR.prop(`_arr_${builder.fields.length}`);
  const proxyParams: o.FnParam[] = [];
@@ -604,7 +599,7 @@ function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[])
 function createCachedLiteralMap(
    builder: ClassBuilder, entries: [string, o.Expression][]): o.Expression {
  if (entries.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_MAP));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_MAP));
  }
  const proxyExpr = o.THIS_EXPR.prop(`_map_${builder.fields.length}`);
  const proxyParams: o.FnParam[] = [];
@@ -8,12 +8,15 @@

 import {CompileTokenMetadata} from '../compile_metadata';
 import {isPresent} from '../facade/lang';
-import {IdentifierSpec, Identifiers, createEnumIdentifier, createIdentifier} from '../identifiers';
+import {IdentifierSpec, Identifiers, resolveEnumIdentifier, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';

 export function createDiTokenExpression(token: CompileTokenMetadata): o.Expression {
  if (isPresent(token.value)) {
    return o.literal(token.value);
+  } else if (token.identifierIsInstance) {
+    return o.importExpr(token.identifier)
+        .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
  } else {
    return o.importExpr(token.identifier);
  }
@@ -21,13 +24,13 @@ export function createDiTokenExpression(token: CompileTokenMetadata): o.Expressi

 export function createInlineArray(values: o.Expression[]): o.Expression {
  if (values.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
  }
  const log2 = Math.log(values.length) / Math.log(2);
  const index = Math.ceil(log2);
  const identifierSpec = index < Identifiers.inlineArrays.length ? Identifiers.inlineArrays[index] :
                                                                   Identifiers.InlineArrayDynamic;
-  const identifier = createIdentifier(identifierSpec);
+  const identifier = resolveIdentifier(identifierSpec);
  return o.importExpr(identifier).instantiate([
    <o.Expression>o.literal(values.length)
  ].concat(values));
@@ -43,7 +46,7 @@ export function createPureProxy(
    throw new Error(`Unsupported number of argument for pure functions: ${argCount}`);
  }
  builder.ctorStmts.push(o.THIS_EXPR.prop(pureProxyProp.name)
-                             .set(o.importExpr(createIdentifier(pureProxyId)).callFn([fn]))
+                             .set(o.importExpr(resolveIdentifier(pureProxyId)).callFn([fn]))
                             .toStmt());
 }

@@ -53,5 +56,5 @@ export function createEnumExpression(enumType: IdentifierSpec, enumValue: any):
  if (!enumName) {
    throw new Error(`Unknown enum value ${enumValue} in ${enumType.name}`);
  }
-  return o.importExpr(createEnumIdentifier(enumType, enumName));
+  return o.importExpr(resolveEnumIdentifier(resolveIdentifier(enumType), enumName));
 }
@@ -8,7 +8,7 @@
 import {SecurityContext} from '@angular/core';

 import {isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 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';
@@ -26,7 +26,7 @@ export function writeToRenderer(
    case PropertyBindingType.Property:
      if (logBindingUpdate) {
        updateStmts.push(
-            o.importExpr(createIdentifier(Identifiers.setBindingDebugInfo))
+            o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfo))
                .callFn([renderer, renderElement, o.literal(boundProp.name), renderValue])
                .toStmt());
      }
@@ -91,8 +91,8 @@ function sanitizedValue(

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

@@ -104,7 +104,7 @@ export function triggerAnimation(
  // 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 unitializedValue = o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED));
  const animationTransitionVar = o.variable('animationTransition_' + animationName);

  updateStmts.push(
@@ -121,32 +121,23 @@ export function triggerAnimation(
          .set(animationFnExpr.callFn([view, renderElement, lastRenderValue, emptyStateValue]))
          .toDeclStmt());

-  const registerStmts: o.Statement[] = [];
-  const animationStartMethodExists = boundOutputs.find(
-      event => event.isAnimation && event.name == animationName && event.phase == 'start');
-  if (animationStartMethodExists) {
-    registerStmts.push(
-        animationTransitionVar
-            .callMethod(
-                'onStart',
-                [eventListener.callMethod(
-                    o.BuiltinMethod.Bind,
-                    [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'start'))])])
-            .toStmt());
-  }
+  const registerStmts = [
+    animationTransitionVar
+        .callMethod(
+            'onStart',
+            [eventListener.callMethod(
+                o.BuiltinMethod.Bind,
+                [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'start'))])])
+        .toStmt(),
+    animationTransitionVar
+        .callMethod(
+            'onDone',
+            [eventListener.callMethod(
+                o.BuiltinMethod.Bind,
+                [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'done'))])])
+        .toStmt(),

-  const animationDoneMethodExists = boundOutputs.find(
-      event => event.isAnimation && event.name == animationName && event.phase == 'done');
-  if (animationDoneMethodExists) {
-    registerStmts.push(
-        animationTransitionVar
-            .callMethod(
-                'onDone',
-                [eventListener.callMethod(
-                    o.BuiltinMethod.Bind,
-                    [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'done'))])])
-            .toStmt());
-  }
+  ];

  updateStmts.push(...registerStmts);
  detachStmts.push(...registerStmts);
@@ -9,7 +9,7 @@
 import {ViewEncapsulation, isDevMode} from '@angular/core';

 import {CompileIdentifierMetadata} from './compile_metadata';
-import {Identifiers, createIdentifier} from './identifiers';
+import {Identifiers, resolveIdentifier} from './identifiers';

 function unimplemented(): any {
  throw new Error('unimplemented');
@@ -61,7 +61,7 @@ export abstract class RenderTypes {
 }

 export class DefaultRenderTypes implements RenderTypes {
-  get renderer() { return createIdentifier(Identifiers.Renderer); };
+  get renderer() { return resolveIdentifier(Identifiers.Renderer); };
  renderText: any = null;
  renderElement: any = null;
  renderComment: any = null;
@@ -6,12 +6,11 @@
 * found in the LICENSE file at https://angular.io/license
 */

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

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

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

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

@@ -71,7 +70,7 @@ export class DirectiveNormalizer {
    } else if (prenormData.templateUrl) {
      normalizedTemplateAsync = this.normalizeTemplateAsync(prenormData);
    } else {
-      throw new SyntaxError(
+      throw new Error(
          `No template specified for component ${stringify(prenormData.componentType)}`);
    }

@@ -105,7 +104,7 @@ export class DirectiveNormalizer {
        template, stringify(prenomData.componentType), false, interpolationConfig);
    if (rootNodesAndErrors.errors.length > 0) {
      const errorString = rootNodesAndErrors.errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw new Error(`Template parse errors:\n${errorString}`);
    }
    const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({
      styles: prenomData.styles,
@@ -6,16 +6,13 @@
 * 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 {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 +20,7 @@ import {splitAtColon} from './util';
 *
 * See {@link Compiler}
 */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveResolver {
  constructor(private _reflector: ReflectorReader = reflector) {}

@@ -38,7 +35,7 @@ export class DirectiveResolver {
  resolve(type: Type<any>, throwIfNotFound = true): Directive {
    const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
    if (typeMetadata) {
-      const metadata = ListWrapper.findLast(typeMetadata, isDirectiveMetadata);
+      const metadata = typeMetadata.find(isDirectiveMetadata);
      if (metadata) {
        const propertyMetadata = this._reflector.propMetadata(type);
        return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
@@ -61,74 +58,85 @@ export class DirectiveResolver {
    const queries: {[key: string]: any} = {};

    Object.keys(propertyMetadata).forEach((propName: string) => {
-      const input = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Input);
-      if (input) {
-        if (input.bindingPropertyName) {
-          inputs.push(`${propName}: ${input.bindingPropertyName}`);
-        } else {
-          inputs.push(propName);
-        }
-      }
-      const output = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Output);
-      if (output) {
-        if (output.bindingPropertyName) {
-          outputs.push(`${propName}: ${output.bindingPropertyName}`);
-        } else {
-          outputs.push(propName);
-        }
-      }
-      const hostBindings = propertyMetadata[propName].filter(a => a && a instanceof HostBinding);
-      hostBindings.forEach(hostBinding => {
-        if (hostBinding.hostPropertyName) {
-          const startWith = hostBinding.hostPropertyName[0];
-          if (startWith === '(') {
-            throw new Error(`@HostBinding can not bind to events. Use @HostListener instead.`);
-          } else if (startWith === '[') {
-            throw new Error(
-                `@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.`);
+
+      propertyMetadata[propName].forEach(a => {
+        if (a instanceof Input) {
+          if (a.bindingPropertyName) {
+            inputs.push(`${propName}: ${a.bindingPropertyName}`);
+          } else {
+            inputs.push(propName);
          }
-          host[`[${hostBinding.hostPropertyName}]`] = propName;
-        } else {
-          host[`[${propName}]`] = propName;
+        } else if (a instanceof Output) {
+          const output: Output = a;
+          if (output.bindingPropertyName) {
+            outputs.push(`${propName}: ${output.bindingPropertyName}`);
+          } else {
+            outputs.push(propName);
+          }
+        } else if (a instanceof HostBinding) {
+          const hostBinding: HostBinding = a;
+          if (hostBinding.hostPropertyName) {
+            const startWith = hostBinding.hostPropertyName[0];
+            if (startWith === '(') {
+              throw new Error(`@HostBinding can not bind to events. Use @HostListener instead.`);
+            } else if (startWith === '[') {
+              throw new Error(
+                  `@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.`);
+            }
+            host[`[${hostBinding.hostPropertyName}]`] = propName;
+          } else {
+            host[`[${propName}]`] = propName;
+          }
+        } else if (a instanceof HostListener) {
+          const hostListener: HostListener = a;
+          const args = hostListener.args || [];
+          host[`(${hostListener.eventName})`] = `${propName}(${args.join(',')})`;
+        } else if (a instanceof Query) {
+          queries[propName] = a;
        }
      });
-      const hostListeners = propertyMetadata[propName].filter(a => a && a instanceof HostListener);
-      hostListeners.forEach(hostListener => {
-        const args = hostListener.args || [];
-        host[`(${hostListener.eventName})`] = `${propName}(${args.join(',')})`;
-      });
-      const query = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Query);
-      if (query) {
-        queries[propName] = query;
-      }
    });
    return this._merge(dm, inputs, outputs, host, queries, directiveType);
  }

  private _extractPublicName(def: string) { return splitAtColon(def, [null, def])[1].trim(); }

-  private _dedupeBindings(bindings: string[]): string[] {
-    const names = new Set<string>();
-    const reversedResult: string[] = [];
-    // go last to first to allow later entries to overwrite previous entries
-    for (let i = bindings.length - 1; i >= 0; i--) {
-      const binding = bindings[i];
-      const name = this._extractPublicName(binding);
-      if (!names.has(name)) {
-        names.add(name);
-        reversedResult.push(binding);
-      }
-    }
-    return reversedResult.reverse();
-  }
-
  private _merge(
      directive: Directive, inputs: string[], outputs: string[], host: {[key: string]: string},
      queries: {[key: string]: any}, directiveType: Type<any>): Directive {
-    const mergedInputs =
-        this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);
-    const mergedOutputs =
-        this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);
+    const mergedInputs: string[] = inputs;
+
+    if (directive.inputs) {
+      const inputNames: string[] =
+          directive.inputs.map((def: string): string => this._extractPublicName(def));
+
+      inputs.forEach((inputDef: string) => {
+        const publicName = this._extractPublicName(inputDef);
+        if (inputNames.indexOf(publicName) > -1) {
+          throw new Error(
+              `Input '${publicName}' defined multiple times in '${stringify(directiveType)}'`);
+        }
+      });
+
+      mergedInputs.unshift(...directive.inputs);
+    }
+
+    const mergedOutputs: string[] = outputs;
+
+    if (directive.outputs) {
+      const outputNames: string[] =
+          directive.outputs.map((def: string): string => this._extractPublicName(def));
+
+      outputs.forEach((outputDef: string) => {
+        const publicName = this._extractPublicName(outputDef);
+        if (outputNames.indexOf(publicName) > -1) {
+          throw new Error(
+              `Output event '${publicName}' defined multiple times in '${stringify(directiveType)}'`);
+        }
+      });
+      mergedOutputs.unshift(...directive.outputs);
+    }
+
    const mergedHost = directive.host ? StringMapWrapper.merge(directive.host, host) : host;
    const mergedQueries =
        directive.queries ? StringMapWrapper.merge(directive.queries, queries) : queries;
@@ -6,14 +6,15 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
+import {Injectable} from '@angular/core';
+
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata} from './compile_metadata';
 import {createCheckBindingField, createCheckBindingStmt} from './compiler_util/binding_util';
 import {EventHandlerVars, convertActionBinding, convertPropertyBinding} from './compiler_util/expression_converter';
 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 {Identifiers, resolveIdentifier} from './identifiers';
 import {DEFAULT_INTERPOLATION_CONFIG} from './ml_parser/interpolation_config';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
@@ -50,11 +51,9 @@ 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)}`;
-  }
+  static dirWrapperClassName(id: CompileIdentifierMetadata) { return `Wrapper_${id.name}`; }

  constructor(
      private compilerConfig: CompilerConfig, private _exprParser: Parser,
@@ -69,7 +68,7 @@ export class DirectiveWrapperCompiler {
      addCheckInputMethod(inputFieldName, builder);
    });
    addNgDoCheckMethod(builder);
-    addCheckHostMethod(hostParseResult.hostProps, hostParseResult.hostListeners, builder);
+    addCheckHostMethod(hostParseResult.hostProps, builder);
    addHandleEventMethod(hostParseResult.hostListeners, builder);
    addSubscribeMethod(dirMeta, builder);

@@ -118,10 +117,10 @@ class DirectiveWrapperBuilder implements ClassBuilder {
          [
            new o.FnParam(
                VIEW_VAR.name,
-                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
            new o.FnParam(
                COMPONENT_VIEW_VAR.name,
-                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
            new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
          ],
          this.detachStmts),
@@ -173,7 +172,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
    }
    if (builder.compilerConfig.logBindingUpdate) {
      onChangesStmts.push(
-          o.importExpr(createIdentifier(Identifiers.setBindingDebugInfoForChanges))
+          o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfoForChanges))
              .callFn(
                  [VIEW_VAR.prop('renderer'), RENDER_EL_VAR, o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])
              .toStmt());
@@ -199,7 +198,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
      'ngDoCheck',
      [
        new o.FnParam(
-            VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+            VIEW_VAR.name, o.importType(resolveIdentifier(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),
      ],
@@ -215,7 +214,7 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
  if (builder.genChanges) {
    onChangeStatements.push(o.THIS_EXPR.prop(CHANGES_FIELD_NAME)
                                .key(o.literal(input))
-                                .set(o.importExpr(createIdentifier(Identifiers.SimpleChange))
+                                .set(o.importExpr(resolveIdentifier(Identifiers.SimpleChange))
                                         .instantiate([field.expression, CURR_VALUE_VAR]))
                                .toStmt());
  }
@@ -234,15 +233,14 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
 }

 function addCheckHostMethod(
-    hostProps: BoundElementPropertyAst[], hostEvents: BoundEventAst[],
-    builder: DirectiveWrapperBuilder) {
+    hostProps: BoundElementPropertyAst[], builder: DirectiveWrapperBuilder) {
  const stmts: o.Statement[] = [];
  const methodParams: o.FnParam[] = [
    new o.FnParam(
-        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
    new o.FnParam(
        COMPONENT_VIEW_VAR.name,
-        o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        o.importType(resolveIdentifier(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),
  ];
@@ -257,14 +255,14 @@ function addCheckHostMethod(
    if (hostProp.needsRuntimeSecurityContext) {
      securityContextExpr = o.variable(`secCtx_${methodParams.length}`);
      methodParams.push(new o.FnParam(
-          securityContextExpr.name, o.importType(createIdentifier(Identifiers.SecurityContext))));
+          securityContextExpr.name, o.importType(resolveIdentifier(Identifiers.SecurityContext))));
    }
    let checkBindingStmts: o.Statement[];
    if (hostProp.isAnimation) {
      const {updateStmts, detachStmts} = triggerAnimation(
-          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp, hostEvents,
+          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp,
          o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME)
-              .or(o.importExpr(createIdentifier(Identifiers.noop))),
+              .or(o.importExpr(resolveIdentifier(Identifiers.noop))),
          RENDER_EL_VAR, evalResult.currValExpr, field.expression);
      checkBindingStmts = updateStmts;
      builder.detachStmts.push(...detachStmts);
@@ -308,7 +306,7 @@ function addHandleEventMethod(hostListeners: BoundEventAst[], builder: Directive
 function addSubscribeMethod(dirMeta: CompileDirectiveMetadata, builder: DirectiveWrapperBuilder) {
  const methodParams: o.FnParam[] = [
    new o.FnParam(
-        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
    new o.FnParam(EVENT_HANDLER_FIELD_NAME, o.DYNAMIC_TYPE)
  ];
  const stmts: o.Statement[] = [
@@ -350,10 +348,9 @@ function parseHostBindings(
  const errors: ParseError[] = [];
  const parser =
      new BindingParser(exprParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors);
-  const moduleUrl = identifierModuleUrl(dirMeta.type);
-  const sourceFileName = moduleUrl ?
-      `in Directive ${identifierName(dirMeta.type)} in ${moduleUrl}` :
-      `in Directive ${identifierName(dirMeta.type)}`;
+  const sourceFileName = dirMeta.type.moduleUrl ?
+      `in Directive ${dirMeta.type.name} in ${dirMeta.type.moduleUrl}` :
+      `in Directive ${dirMeta.type.name}`;
  const sourceFile = new ParseSourceFile('', sourceFileName);
  const sourceSpan = new ParseSourceSpan(
      new ParseLocation(sourceFile, null, null, null),
@@ -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);
@@ -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[] = [];

@@ -343,7 +344,7 @@ export class _ParseAST {
        while (this.optionalCharacter(chars.$COLON)) {
          args.push(this.parseExpression());
        }
-        result = new BindingPipe(this.span(result.span.start), result, name, args);
+        result = new BindingPipe(this.span(result.span.start - this.offset), result, name, args);
      } while (this.optionalOperator('|'));
    }

@@ -8,16 +8,10 @@

 import * as i18n from './i18n_ast';

-export function digest(message: i18n.Message): string {
+export function digestMessage(message: i18n.Message): string {
  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 computeMsgId(parts.join(''), message.meaning);
-}
-
 /**
 * Serialize the i18n ast to something xml-like in order to generate an UID.
 *
@@ -45,7 +39,7 @@ class _SerializerVisitor implements i18n.Visitor {
  }

  visitPlaceholder(ph: i18n.Placeholder, context: any): any {
-    return ph.value ? `<ph name="${ph.name}">${ph.value}</ph>` : `<ph name="${ph.name}"/>`;
+    return `<ph name="${ph.name}">${ph.value}</ph>`;
  }

  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): any {
@@ -59,21 +53,6 @@ export function serializeNodes(nodes: i18n.Node[]): string[] {
  return nodes.map(a => a.visit(serializerVisitor, null));
 }

-/**
- * Serialize the i18n ast to something xml-like in order to generate an UID.
- *
- * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.
- *
- * @internal
- */
-class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
-  visitIcu(icu: i18n.Icu, context: any): any {
-    let strCases = Object.keys(icu.cases).map((k: string) => `${k} {${icu.cases[k].visit(this)}}`);
-    // Do not take the expression into account
-    return `{${icu.type}, ${strCases.join(', ')}}`;
-  }
-}
-
 /**
 * Compute the SHA1 of the given string
 *
@@ -84,7 +63,7 @@ class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
 */
 export function sha1(str: string): string {
  const utf8 = utf8Encode(str);
-  const words32 = stringToWords32(utf8, Endian.Big);
+  const words32 = stringToWords32(utf8);
  const len = utf8.length * 8;

  const w = new Array(80);
@@ -111,99 +90,15 @@ export function sha1(str: string): string {
    [a, b, c, d, e] = [add32(a, h0), add32(b, h1), add32(c, h2), add32(d, h3), add32(e, h4)];
  }

-  return byteStringToHexString(words32ToByteString([a, b, c, d, e]));
-}
+  const sha1 = words32ToString([a, b, c, d, e]);

-function fk(index: number, b: number, c: number, d: number): [number, number] {
-  if (index < 20) {
-    return [(b & c) | (~b & d), 0x5a827999];
+  let hex: string = '';
+  for (let i = 0; i < sha1.length; i++) {
+    const b = sha1.charCodeAt(i);
+    hex += (b >>> 4 & 0x0f).toString(16) + (b & 0x0f).toString(16);
  }

-  if (index < 40) {
-    return [b ^ c ^ d, 0x6ed9eba1];
-  }
-
-  if (index < 60) {
-    return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
-  }
-
-  return [b ^ c ^ d, 0xca62c1d6];
-}
-
-/**
- * Compute the fingerprint of the given string
- *
- * The output is 64 bit number encoded as a decimal string
- *
- * based on:
- * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
- */
-export function fingerprint(str: string): [number, number] {
-  const utf8 = utf8Encode(str);
-
-  let [hi, lo] = [hash32(utf8, 0), hash32(utf8, 102072)];
-
-  if (hi == 0 && (lo == 0 || lo == 1)) {
-    hi = hi ^ 0x130f9bef;
-    lo = lo ^ -0x6b5f56d8;
-  }
-
-  return [hi, lo];
-}
-
-export function computeMsgId(msg: string, meaning: string): string {
-  let [hi, lo] = fingerprint(msg);
-
-  if (meaning) {
-    const [him, lom] = fingerprint(meaning);
-    [hi, lo] = add64(rol64([hi, lo], 1), [him, lom]);
-  }
-
-  return byteStringToDecString(words32ToByteString([hi & 0x7fffffff, lo]));
-}
-
-function hash32(str: string, c: number): number {
-  let [a, b] = [0x9e3779b9, 0x9e3779b9];
-  let i: number;
-
-  const len = str.length;
-
-  for (i = 0; i + 12 <= len; i += 12) {
-    a = add32(a, wordAt(str, i, Endian.Little));
-    b = add32(b, wordAt(str, i + 4, Endian.Little));
-    c = add32(c, wordAt(str, i + 8, Endian.Little));
-    [a, b, c] = mix([a, b, c]);
-  }
-
-  a = add32(a, wordAt(str, i, Endian.Little));
-  b = add32(b, wordAt(str, i + 4, Endian.Little));
-  // the first byte of c is reserved for the length
-  c = add32(c, len);
-  c = add32(c, wordAt(str, i + 8, Endian.Little) << 8);
-
-  return mix([a, b, c])[2];
-}
-
-// clang-format off
-function mix([a, b, c]: [number, number, number]): [number, number, number] {
-  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 13;
-  b = sub32(b, c); b = sub32(b, a); b ^= a << 8;
-  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 13;
-  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 12;
-  b = sub32(b, c); b = sub32(b, a); b ^= a << 16;
-  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 5;
-  a = sub32(a, b); a = sub32(a, c); a ^= c >>> 3;
-  b = sub32(b, c); b = sub32(b, a); b ^= a << 10;
-  c = sub32(c, a); c = sub32(c, b); c ^= b >>> 15;
-  return [a, b, c];
-}
-// clang-format on
-
-// Utils
-
-enum Endian {
-  Little,
-  Big,
+  return hex.toLowerCase();
 }

 function utf8Encode(str: string): string {
@@ -236,9 +131,10 @@ function decodeSurrogatePairs(str: string, index: number): number {
  }

  const high = str.charCodeAt(index);
+  let low: number;

  if (high >= 0xd800 && high <= 0xdfff && str.length > index + 1) {
-    const low = byteAt(str, index + 1);
+    low = str.charCodeAt(index + 1);
    if (low >= 0xdc00 && low <= 0xdfff) {
      return (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000;
    }
@@ -247,126 +143,50 @@ function decodeSurrogatePairs(str: string, index: number): number {
  return high;
 }

-function add32(a: number, b: number): number {
-  return add32to64(a, b)[1];
-}
-
-function add32to64(a: number, b: number): [number, number] {
-  const low = (a & 0xffff) + (b & 0xffff);
-  const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
-  return [high >>> 16, (high << 16) | (low & 0xffff)];
-}
-
-function add64([ah, al]: [number, number], [bh, bl]: [number, number]): [number, number] {
-  const [carry, l] = add32to64(al, bl);
-  const h = add32(add32(ah, bh), carry);
-  return [h, l];
-}
-
-function sub32(a: number, b: number): number {
-  const low = (a & 0xffff) - (b & 0xffff);
-  const high = (a >> 16) - (b >> 16) + (low >> 16);
-  return (high << 16) | (low & 0xffff);
-}
-
-// Rotate a 32b number left `count` position
-function rol32(a: number, count: number): number {
-  return (a << count) | (a >>> (32 - count));
-}
-
-// Rotate a 64b number left `count` position
-function rol64([hi, lo]: [number, number], count: number): [number, number] {
-  const h = (hi << count) | (lo >>> (32 - count));
-  const l = (lo << count) | (hi >>> (32 - count));
-  return [h, l];
-}
-
-function stringToWords32(str: string, endian: Endian): number[] {
-  const words32 = Array((str.length + 3) >>> 2);
+function stringToWords32(str: string): number[] {
+  const words32 = Array(str.length >>> 2);

  for (let i = 0; i < words32.length; i++) {
-    words32[i] = wordAt(str, i * 4, endian);
+    words32[i] = 0;
+  }
+
+  for (let i = 0; i < str.length; i++) {
+    words32[i >>> 2] |= (str.charCodeAt(i) & 0xff) << 8 * (3 - i & 0x3);
  }

  return words32;
 }

-function byteAt(str: string, index: number): number {
-  return index >= str.length ? 0 : str.charCodeAt(index) & 0xff;
-}
-
-function wordAt(str: string, index: number, endian: Endian): number {
-  let word = 0;
-  if (endian === Endian.Big) {
-    for (let i = 0; i < 4; i++) {
-      word += byteAt(str, index + i) << (24 - 8 * i);
-    }
-  } else {
-    for (let i = 0; i < 4; i++) {
-      word += byteAt(str, index + i) << 8 * i;
-    }
-  }
-  return word;
-}
-
-function words32ToByteString(words32: number[]): string {
-  return words32.reduce((str, word) => str + word32ToByteString(word), '');
-}
-
-function word32ToByteString(word: number): string {
+function words32ToString(words32: number[]): string {
  let str = '';
-  for (let i = 0; i < 4; i++) {
-    str += String.fromCharCode((word >>> 8 * (3 - i)) & 0xff);
+  for (let i = 0; i < words32.length * 4; i++) {
+    str += String.fromCharCode((words32[i >>> 2] >>> 8 * (3 - i & 0x3)) & 0xff);
  }
  return str;
 }

-function byteStringToHexString(str: string): string {
-  let hex: string = '';
-  for (let i = 0; i < str.length; i++) {
-    const b = byteAt(str, i);
-    hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);
-  }
-  return hex.toLowerCase();
-}
-
-// based on http://www.danvk.org/hex2dec.html (JS can not handle more than 56b)
-function byteStringToDecString(str: string): string {
-  let decimal = '';
-  let toThePower = '1';
-
-  for (let i = str.length - 1; i >= 0; i--) {
-    decimal = addBigInt(decimal, numberTimesBigInt(byteAt(str, i), toThePower));
-    toThePower = numberTimesBigInt(256, toThePower);
+function fk(index: number, b: number, c: number, d: number): [number, number] {
+  if (index < 20) {
+    return [(b & c) | (~b & d), 0x5a827999];
  }

-  return decimal.split('').reverse().join('');
-}
-
-// x and y decimal, lowest significant digit first
-function addBigInt(x: string, y: string): string {
-  let sum = '';
-  const len = Math.max(x.length, y.length);
-  for (let i = 0, carry = 0; i < len || carry; i++) {
-    const tmpSum = carry + +(x[i] || 0) + +(y[i] || 0);
-    if (tmpSum >= 10) {
-      carry = 1;
-      sum += tmpSum - 10;
-    } else {
-      carry = 0;
-      sum += tmpSum;
-    }
+  if (index < 40) {
+    return [b ^ c ^ d, 0x6ed9eba1];
  }

-  return sum;
+  if (index < 60) {
+    return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];
+  }
+
+  return [b ^ c ^ d, 0xca62c1d6];
 }

-function numberTimesBigInt(num: number, b: string): string {
-  let product = '';
-  let bToThePower = b;
-  for (; num !== 0; num = num >>> 1) {
-    if (num & 1) product = addBigInt(product, bToThePower);
-    bToThePower = addBigInt(bToThePower, bToThePower);
-  }
-  return product;
+function add32(a: number, b: number): number {
+  const low = (a & 0xffff) + (b & 0xffff);
+  const high = (a >> 16) + (b >> 16) + (low >> 16);
+  return (high << 16) | (low & 0xffff);
 }
+
+function rol32(a: number, count: number): number {
+  return (a << count) | (a >>> (32 - count));
+}
@@ -12,12 +12,9 @@
 */
 import {ViewEncapsulation} from '@angular/core';

-import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
+import {analyzeAndValidateNgModules, extractProgramSymbols, loadNgModuleDirectives} 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 {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
+import {StaticReflector, StaticReflectorHost} from '../aot/static_reflector';
 import {CompileDirectiveMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import {DirectiveNormalizer} from '../directive_normalizer';
@@ -28,17 +25,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 {
  /**
   * Loads a resource (e.g. html / css)
   */
@@ -47,53 +50,48 @@ 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);
-    return Promise
-        .all(ngModules.map(
-            ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
-                ngModule.type.reference, false)))
-        .then(() => {
-          const errors: ParseError[] = [];
+        analyzeAndValidateNgModules(programSymbols, this.options, this.metadataResolver);
+    return loadNgModuleDirectives(ngModules).then(() => {
+      const errors: ParseError[] = [];

-          files.forEach(file => {
-            const compMetas: CompileDirectiveMetadata[] = [];
-            file.directives.forEach(directiveType => {
-              const dirMeta = this.metadataResolver.getDirectiveMetadata(directiveType);
-              if (dirMeta && dirMeta.isComponent) {
-                compMetas.push(dirMeta);
-              }
-            });
-            compMetas.forEach(compMeta => {
-              const html = compMeta.template.template;
-              const interpolationConfig =
-                  InterpolationConfig.fromArray(compMeta.template.interpolation);
-              errors.push(
-                  ...this.messageBundle.updateFromTemplate(html, file.srcUrl, interpolationConfig));
-            });
-          });
-
-          if (errors.length) {
-            throw new Error(errors.map(e => e.toString()).join('\n'));
+      files.forEach(file => {
+        const compMetas: CompileDirectiveMetadata[] = [];
+        file.directives.forEach(directiveType => {
+          const dirMeta = this.metadataResolver.getDirectiveMetadata(directiveType);
+          if (dirMeta && dirMeta.isComponent) {
+            compMetas.push(dirMeta);
          }
-
-          return this.messageBundle;
        });
+        compMetas.forEach(compMeta => {
+          const html = compMeta.template.template;
+          const interpolationConfig =
+              InterpolationConfig.fromArray(compMeta.template.interpolation);
+          errors.push(
+              ...this.messageBundle.updateFromTemplate(html, file.srcUrl, interpolationConfig));
+        });
+      });
+
+      if (errors.length) {
+        throw new Error(errors.map(e => e.toString()).join('\n'));
+      }
+
+      return this.messageBundle;
+    });
  }

-  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 +106,12 @@ export class Extractor {
    const elementSchemaRegistry = new DomElementSchemaRegistry();
    const resolver = new CompileMetadataResolver(
        new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-        new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-        staticReflector);
+        new PipeResolver(staticReflector), 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};
  }
 }
@@ -10,6 +10,7 @@ import * as html from '../ml_parser/ast';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {ParseTreeResult} from '../ml_parser/parser';

+import {digestMessage} from './digest';
 import * as i18n from './i18n_ast';
 import {createI18nMessageFactory} from './i18n_parser';
 import {I18nError} from './parse_util';
@@ -213,8 +214,8 @@ class _Visitor implements html.Visitor {
    // Extract only top level nodes with the (implicit) "i18n" attribute if not in a block or an ICU
    // message
    const i18nAttr = _getI18nAttr(el);
-    const isImplicit = this._implicitTags.some(tag => el.name === tag) && !this._inIcu &&
-        !this._isInTranslatableSection;
+    const isImplicit = this._implicitTags.some((tag: string): boolean => el.name === tag) &&
+        !this._inIcu && !this._isInTranslatableSection;
    const isTopLevelImplicit = !wasInImplicitNode && isImplicit;
    this._inImplicitNode = this._inImplicitNode || isImplicit;

@@ -347,14 +348,14 @@ class _Visitor implements html.Visitor {
  // no-op when called in extraction mode (returns [])
  private _translateMessage(el: html.Node, message: i18n.Message): html.Node[] {
    if (message && this._mode === _VisitorMode.Merge) {
-      const nodes = this._translations.get(message);
+      const id = digestMessage(message);
+      const nodes = this._translations.get(id);

      if (nodes) {
        return nodes;
      }

-      this._reportError(
-          el, `Translation unavailable for message id="${this._translations.digest(message)}"`);
+      this._reportError(el, `Translation unavailable for message id="${id}"`);
    }

    return [];
@@ -383,20 +384,19 @@ 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 nodes = this._translations.get(message);
+        const id = digestMessage(message);
+        const nodes = this._translations.get(id);
        if (nodes) {
          if (nodes[0] instanceof html.Text) {
            const value = (nodes[0] as html.Text).value;
            translatedAttributes.push(new html.Attribute(attr.name, value, attr.sourceSpan));
          } else {
            this._reportError(
-                el,
-                `Unexpected translation for attribute "${attr.name}" (id="${this._translations.digest(message)}")`);
+                el, `Unexpected translation for attribute "${attr.name}" (id="${id}")`);
          }
        } else {
          this._reportError(
-              el,
-              `Translation unavailable for attribute "${attr.name}" (id="${this._translations.digest(message)}")`);
+              el, `Translation unavailable for attribute "${attr.name}" (id="${id}")`);
        }
      } else {
        translatedAttributes.push(attr);
@@ -12,20 +12,18 @@ export class Message {
  /**
   * @param nodes message AST
   * @param placeholders maps placeholder names to static content
-   * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
+   * @param placeholderToMsgIds maps placeholder names to translatable message IDs (used for ICU
+   *                            messages)
   * @param meaning
   * @param description
   */
  constructor(
-      public nodes: Node[], public placeholders: {[phName: string]: string},
-      public placeholderToMessage: {[phName: string]: Message}, public meaning: string,
+      public nodes: Node[], public placeholders: {[name: string]: string},
+      public placeholderToMsgIds: {[name: string]: string}, public meaning: string,
      public description: string) {}
 }

-export interface Node {
-  sourceSpan: ParseSourceSpan;
-  visit(visitor: Visitor, context?: any): any;
-}
+export interface Node { visit(visitor: Visitor, context?: any): any; }

 export class Text implements Node {
  constructor(public value: string, public sourceSpan: ParseSourceSpan) {}
@@ -33,7 +31,6 @@ export class Text implements Node {
  visit(visitor: Visitor, context?: any): any { return visitor.visitText(this, context); }
 }

-// TODO(vicb): do we really need this node (vs an array) ?
 export class Container implements Node {
  constructor(public children: Node[], public sourceSpan: ParseSourceSpan) {}

@@ -41,7 +38,6 @@ export class Container implements Node {
 }

 export class Icu implements Node {
-  public expressionPlaceholder: string;
  constructor(
      public expression: string, public type: string, public cases: {[k: string]: Node},
      public sourceSpan: ParseSourceSpan) {}
@@ -59,13 +55,13 @@ export class TagPlaceholder implements Node {
 }

 export class Placeholder implements Node {
-  constructor(public value: string, public name: string, public sourceSpan: ParseSourceSpan) {}
+  constructor(public value: string, public name: string = '', public sourceSpan: ParseSourceSpan) {}

  visit(visitor: Visitor, context?: any): any { return visitor.visitPlaceholder(this, context); }
 }

 export class IcuPlaceholder implements Node {
-  constructor(public value: Icu, public name: string, public sourceSpan: ParseSourceSpan) {}
+  constructor(public value: Icu, public name: string = '', public sourceSpan: ParseSourceSpan) {}

  visit(visitor: Visitor, context?: any): any { return visitor.visitIcuPlaceholder(this, context); }
 }
@@ -11,6 +11,7 @@ import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/in
 import {ParseTreeResult} from '../ml_parser/parser';

 import {mergeTranslations} from './extractor_merger';
+import {MessageBundle} from './message_bundle';
 import {Serializer} from './serializers/serializer';
 import {Xliff} from './serializers/xliff';
 import {Xmb} from './serializers/xmb';
@@ -40,29 +41,32 @@ export class I18NHtmlParser implements HtmlParser {
    }

    // TODO(vicb): add support for implicit tags / attributes
+    const messageBundle = new MessageBundle(this._htmlParser, [], {});
+    const errors = messageBundle.updateFromTemplate(source, url, interpolationConfig);

-    if (parseResult.errors.length) {
-      return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);
+    if (errors && errors.length) {
+      return new ParseTreeResult(parseResult.rootNodes, parseResult.errors.concat(errors));
    }

-    const serializer = this._createSerializer();
-    const translationBundle = TranslationBundle.load(this._translations, url, serializer);
+    const serializer = this._createSerializer(interpolationConfig);
+    const translationBundle =
+        TranslationBundle.load(this._translations, url, messageBundle, serializer);

    return mergeTranslations(parseResult.rootNodes, translationBundle, interpolationConfig, [], {});
  }

-  private _createSerializer(): Serializer {
+  private _createSerializer(interpolationConfig: InterpolationConfig): Serializer {
    const format = (this._translationsFormat || 'xlf').toLowerCase();

    switch (format) {
      case 'xmb':
        return new Xmb();
      case 'xtb':
-        return new Xtb();
+        return new Xtb(this._htmlParser, interpolationConfig);
      case 'xliff':
      case 'xlf':
      default:
-        return new Xliff();
+        return new Xliff(this._htmlParser, interpolationConfig);
    }
  }
 }
@@ -12,6 +12,7 @@ import * as html from '../ml_parser/ast';
 import {getHtmlTagDefinition} from '../ml_parser/html_tags';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {ParseSourceSpan} from '../parse_util';
+import {digestMessage} from './digest';

 import * as i18n from './i18n_ast';
 import {PlaceholderRegistry} from './serializers/placeholder';
@@ -33,8 +34,8 @@ class _I18nVisitor implements html.Visitor {
  private _isIcu: boolean;
  private _icuDepth: number;
  private _placeholderRegistry: PlaceholderRegistry;
-  private _placeholderToContent: {[phName: string]: string};
-  private _placeholderToMessage: {[phName: string]: i18n.Message};
+  private _placeholderToContent: {[name: string]: string};
+  private _placeholderToIds: {[name: string]: string};

  constructor(
      private _expressionParser: ExpressionParser,
@@ -45,12 +46,12 @@ class _I18nVisitor implements html.Visitor {
    this._icuDepth = 0;
    this._placeholderRegistry = new PlaceholderRegistry();
    this._placeholderToContent = {};
-    this._placeholderToMessage = {};
+    this._placeholderToIds = {};

    const i18nodes: i18n.Node[] = html.visitAll(this, nodes, {});

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

  visitElement(el: html.Element, context: any): i18n.Node {
@@ -98,13 +99,7 @@ class _I18nVisitor implements html.Visitor {
    this._icuDepth--;

    if (this._isIcu || this._icuDepth > 0) {
-      // Returns an ICU node when:
-      // - the message (vs a part of the message) is an ICU message, or
-      // - the ICU message is nested.
-      const expPh = this._placeholderRegistry.getUniquePlaceholder(`VAR_${icu.type}`);
-      i18nIcu.expressionPlaceholder = expPh;
-      this._placeholderToContent[expPh] = icu.switchValue;
-
+      // If the message (vs a part of the message) is an ICU message returns it
      return i18nIcu;
    }

@@ -115,7 +110,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._placeholderToIds[phName] = digestMessage(visitor.toI18nMessage([icu], '', ''));
    return new i18n.IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);
  }

@@ -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';
@@ -10,6 +10,7 @@ import {HtmlParser} from '../ml_parser/html_parser';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {ParseError} from '../parse_util';

+import {digestMessage} from './digest';
 import {extractMessages} from './extractor_merger';
 import {Message} from './i18n_ast';
 import {Serializer} from './serializers/serializer';
@@ -18,7 +19,7 @@ import {Serializer} from './serializers/serializer';
 * A container for message extracted from the templates.
 */
 export class MessageBundle {
-  private _messages: Message[] = [];
+  private _messageMap: {[id: string]: Message} = {};

  constructor(
      private _htmlParser: HtmlParser, private _implicitTags: string[],
@@ -39,10 +40,11 @@ export class MessageBundle {
      return i18nParserResult.errors;
    }

-    this._messages.push(...i18nParserResult.messages);
+    i18nParserResult.messages.forEach(
+        (message) => { this._messageMap[digestMessage(message)] = message; });
  }

-  getMessages(): Message[] { return this._messages; }
+  getMessageMap(): {[id: string]: Message} { return this._messageMap; }

-  write(serializer: Serializer): string { return serializer.write(this._messages); }
+  write(serializer: Serializer): string { return serializer.write(this._messageMap); }
 }
@@ -40,9 +40,7 @@ const TAG_TO_PLACEHOLDER_NAMES: {[k: string]: string} = {
 };

 /**
- * Creates unique names for placeholder with different content.
- *
- * Returns the same placeholder name when the content is identical.
+ * Creates unique names for placeholder with different content
 *
 * @internal
 */
@@ -95,10 +93,6 @@ export class PlaceholderRegistry {
    return uniqueName;
  }

-  getUniquePlaceholder(name: string): string {
-    return this._generateUniqueName(name.toUpperCase());
-  }
-
  // Generate a hash for a tag - does not take attribute order into account
  private _hashTag(tag: string, attrs: {[k: string]: string}, isVoid: boolean): string {
    const start = `<${tag}`;
@@ -111,8 +105,18 @@ export class PlaceholderRegistry {
  private _hashClosingTag(tag: string): string { return this._hashTag(`/${tag}`, {}, false); }

  private _generateUniqueName(base: string): string {
-    const next = this._placeHolderNameCounts[base];
-    this._placeHolderNameCounts[base] = next ? next + 1 : 1;
-    return next ? `${base}_${next}` : base;
+    let name = base;
+    let next = this._placeHolderNameCounts[name];
+
+    if (!next) {
+      next = 1;
+    } else {
+      name += `_${next}`;
+      next++;
+    }
+
+    this._placeHolderNameCounts[base] = next;
+
+    return name;
  }
 }
@@ -6,12 +6,36 @@
 * found in the LICENSE file at https://angular.io/license
 */

+import * as html from '../../ml_parser/ast';
 import * as i18n from '../i18n_ast';
+import {MessageBundle} from '../message_bundle';

 export interface Serializer {
-  write(messages: i18n.Message[]): string;
+  write(messageMap: {[id: string]: i18n.Message}): string;

-  load(content: string, url: string): {[msgId: string]: i18n.Node[]};
+  load(content: string, url: string, messageBundle: MessageBundle): {[id: string]: html.Node[]};
+}

-  digest(message: i18n.Message): string;
+// Generate a map of placeholder to content indexed by message ids
+export function extractPlaceholders(messageBundle: MessageBundle) {
+  const messageMap = messageBundle.getMessageMap();
+  const placeholders: {[id: string]: {[name: string]: string}} = {};
+
+  Object.keys(messageMap).forEach(msgId => {
+    placeholders[msgId] = messageMap[msgId].placeholders;
+  });
+
+  return placeholders;
+}
+
+// Generate a map of placeholder to message ids indexed by message ids
+export function extractPlaceholderToIds(messageBundle: MessageBundle) {
+  const messageMap = messageBundle.getMessageMap();
+  const placeholderToIds: {[id: string]: {[name: string]: string}} = {};
+
+  Object.keys(messageMap).forEach(msgId => {
+    placeholderToIds[msgId] = messageMap[msgId].placeholderToMsgIds;
+  });
+
+  return placeholderToIds;
 }
@@ -7,12 +7,15 @@
 */

 import * as ml from '../../ml_parser/ast';
+import {HtmlParser} from '../../ml_parser/html_parser';
+import {InterpolationConfig} from '../../ml_parser/interpolation_config';
 import {XmlParser} from '../../ml_parser/xml_parser';
-import {digest} from '../digest';
+import {ParseError} from '../../parse_util';
 import * as i18n from '../i18n_ast';
+import {MessageBundle} from '../message_bundle';
 import {I18nError} from '../parse_util';

-import {Serializer} from './serializer';
+import {Serializer, extractPlaceholderToIds, extractPlaceholders} from './serializer';
 import * as xml from './xml_helper';

 const _VERSION = '1.2';
@@ -20,7 +23,6 @@ const _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';
 // TODO(vicb): make this a param (s/_/-/)
 const _SOURCE_LANG = 'en';
 const _PLACEHOLDER_TAG = 'x';
-
 const _SOURCE_TAG = 'source';
 const _TARGET_TAG = 'target';
 const _UNIT_TAG = 'trans-unit';
@@ -28,19 +30,17 @@ const _UNIT_TAG = 'trans-unit';
 // http://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html
 // http://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html
 export class Xliff implements Serializer {
-  write(messages: i18n.Message[]): string {
+  constructor(private _htmlParser: HtmlParser, private _interpolationConfig: InterpolationConfig) {}
+
+  write(messageMap: {[id: string]: i18n.Message}): string {
    const visitor = new _WriteVisitor();
-    const visited: {[id: string]: boolean} = {};
+
    const transUnits: xml.Node[] = [];

-    messages.forEach(message => {
-      const id = this.digest(message);
+    Object.keys(messageMap).forEach((id) => {
+      const message = messageMap[id];

-      // deduplicate messages
-      if (visited[id]) return;
-      visited[id] = true;
-
-      const transUnit = new xml.Tag(_UNIT_TAG, {id, datatype: 'html'});
+      const transUnit = new xml.Tag(_UNIT_TAG, {id: id, datatype: 'html'});
      transUnit.children.push(
          new xml.CR(8), new xml.Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes)),
          new xml.CR(8), new xml.Tag(_TARGET_TAG));
@@ -75,28 +75,38 @@ export class Xliff implements Serializer {
    ]);
  }

-  load(content: string, url: string): {[msgId: string]: i18n.Node[]} {
-    // xliff to xml nodes
-    const xliffParser = new XliffParser();
-    const {mlNodesByMsgId, errors} = xliffParser.parse(content, url);
+  load(content: string, url: string, messageBundle: MessageBundle): {[id: string]: ml.Node[]} {
+    // Parse the xtb file into xml nodes
+    const result = new XmlParser().parse(content, url);

-    // xml nodes to i18n nodes
-    const i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {};
-    const converter = new XmlToI18n();
-    Object.keys(mlNodesByMsgId).forEach(msgId => {
-      const {i18nNodes, errors: e} = converter.convert(mlNodesByMsgId[msgId]);
-      errors.push(...e);
-      i18nNodesByMsgId[msgId] = i18nNodes;
-    });
-
-    if (errors.length) {
-      throw new Error(`xliff parse errors:\n${errors.join('\n')}`);
+    if (result.errors.length) {
+      throw new Error(`xtb parse errors:\n${result.errors.join('\n')}`);
    }

-    return i18nNodesByMsgId;
-  }
+    // Replace the placeholders, messages are now string
+    const {messages, errors} = new _LoadVisitor().parse(result.rootNodes, messageBundle);

-  digest(message: i18n.Message): string { return digest(message); }
+    if (errors.length) {
+      throw new Error(`xtb parse errors:\n${errors.join('\n')}`);
+    }
+
+    // Convert the string messages to html ast
+    // TODO(vicb): map error message back to the original message in xtb
+    const messageMap: {[id: string]: ml.Node[]} = {};
+    const parseErrors: ParseError[] = [];
+
+    Object.keys(messages).forEach((id) => {
+      const res = this._htmlParser.parse(messages[id], url, true, this._interpolationConfig);
+      parseErrors.push(...res.errors);
+      messageMap[id] = res.rootNodes;
+    });
+
+    if (parseErrors.length) {
+      throw new Error(`xtb parse errors:\n${parseErrors.join('\n')}`);
+    }
+
+    return messageMap;
+  }
 }

 class _WriteVisitor implements i18n.Visitor {
@@ -156,46 +166,75 @@ class _WriteVisitor implements i18n.Visitor {
 }

 // TODO(vicb): add error management (structure)
-// Extract messages as xml nodes from the xliff file
-class XliffParser implements ml.Visitor {
-  private _unitMlNodes: ml.Node[];
+// TODO(vicb): factorize (xtb) ?
+class _LoadVisitor implements ml.Visitor {
+  private _messageNodes: [string, ml.Node[]][];
+  private _translatedMessages: {[id: string]: string};
+  private _msgId: string;
+  private _target: ml.Node[];
  private _errors: I18nError[];
-  private _mlNodesByMsgId: {[msgId: string]: ml.Node[]};
+  private _placeholders: {[name: string]: string};
+  private _placeholderToIds: {[name: string]: string};

-  parse(xliff: string, url: string) {
-    this._unitMlNodes = [];
-    this._mlNodesByMsgId = {};
+  parse(nodes: ml.Node[], messageBundle: MessageBundle):
+      {messages: {[k: string]: string}, errors: I18nError[]} {
+    this._messageNodes = [];
+    this._translatedMessages = {};
+    this._msgId = '';
+    this._target = [];
+    this._errors = [];

-    const xml = new XmlParser().parse(xliff, url, false);
+    // Find all messages
+    ml.visitAll(this, nodes, null);

-    this._errors = xml.errors;
-    ml.visitAll(this, xml.rootNodes, null);
+    const messageMap = messageBundle.getMessageMap();
+    const placeholders = extractPlaceholders(messageBundle);
+    const placeholderToIds = extractPlaceholderToIds(messageBundle);

-    return {
-      mlNodesByMsgId: this._mlNodesByMsgId,
-      errors: this._errors,
-    };
+    this._messageNodes
+        .filter(message => {
+          // Remove any messages that is not present in the source message bundle.
+          return messageMap.hasOwnProperty(message[0]);
+        })
+        .sort((a, b) => {
+          // Because there could be no ICU placeholders inside an ICU message,
+          // we do not need to take into account the `placeholderToMsgIds` of the referenced
+          // messages, those would always be empty
+          // TODO(vicb): overkill - create 2 buckets and [...woDeps, ...wDeps].process()
+          if (Object.keys(messageMap[a[0]].placeholderToMsgIds).length == 0) {
+            return -1;
+          }
+
+          if (Object.keys(messageMap[b[0]].placeholderToMsgIds).length == 0) {
+            return 1;
+          }
+
+          return 0;
+        })
+        .forEach(message => {
+          const id = message[0];
+          this._placeholders = placeholders[id] || {};
+          this._placeholderToIds = placeholderToIds[id] || {};
+          // TODO(vicb): make sure there is no `_TRANSLATIONS_TAG` nor `_TRANSLATION_TAG`
+          this._translatedMessages[id] = ml.visitAll(this, message[1]).join('');
+        });
+
+    return {messages: this._translatedMessages, errors: this._errors};
  }

  visitElement(element: ml.Element, context: any): any {
    switch (element.name) {
      case _UNIT_TAG:
-        this._unitMlNodes = null;
-        const idAttr = element.attrs.find((attr) => attr.name === 'id');
-        if (!idAttr) {
+        this._target = null;
+        const msgId = element.attrs.find((attr) => attr.name === 'id');
+        if (!msgId) {
          this._addError(element, `<${_UNIT_TAG}> misses the "id" attribute`);
        } else {
-          const id = idAttr.value;
-          if (this._mlNodesByMsgId.hasOwnProperty(id)) {
-            this._addError(element, `Duplicated translations for msg ${id}`);
-          } else {
-            ml.visitAll(this, element.children, null);
-            if (this._unitMlNodes) {
-              this._mlNodesByMsgId[id] = this._unitMlNodes;
-            } else {
-              this._addError(element, `Message ${id} misses a translation`);
-            }
-          }
+          this._msgId = msgId.value;
+        }
+        ml.visitAll(this, element.children, null);
+        if (this._msgId !== null) {
+          this._messageNodes.push([this._msgId, this._target]);
        }
        break;

@@ -204,65 +243,48 @@ class XliffParser implements ml.Visitor {
        break;

      case _TARGET_TAG:
-        this._unitMlNodes = element.children;
+        this._target = element.children;
+        break;
+
+      case _PLACEHOLDER_TAG:
+        const idAttr = element.attrs.find((attr) => attr.name === 'id');
+        if (!idAttr) {
+          this._addError(element, `<${_PLACEHOLDER_TAG}> misses the "id" attribute`);
+        } else {
+          const id = idAttr.value;
+          if (this._placeholders.hasOwnProperty(id)) {
+            return this._placeholders[id];
+          }
+          if (this._placeholderToIds.hasOwnProperty(id) &&
+              this._translatedMessages.hasOwnProperty(this._placeholderToIds[id])) {
+            return this._translatedMessages[this._placeholderToIds[id]];
+          }
+          // TODO(vicb): better error message for when
+          // !this._translatedMessages.hasOwnProperty(this._placeholderToIds[id])
+          this._addError(element, `The placeholder "${id}" does not exists in the source message`);
+        }
        break;

      default:
-        // TODO(vicb): assert file structure, xliff version
-        // For now only recurse on unhandled nodes
        ml.visitAll(this, element.children, null);
    }
  }

-  visitAttribute(attribute: ml.Attribute, context: any): any {}
-
-  visitText(text: ml.Text, context: any): any {}
-
-  visitComment(comment: ml.Comment, context: any): any {}
-
-  visitExpansion(expansion: ml.Expansion, context: any): any {}
-
-  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {}
-
-  private _addError(node: ml.Node, message: string): void {
-    this._errors.push(new I18nError(node.sourceSpan, message));
-  }
-}
-
-// Convert ml nodes (xliff syntax) to i18n nodes
-class XmlToI18n implements ml.Visitor {
-  private _errors: I18nError[];
-
-  convert(nodes: ml.Node[]) {
-    this._errors = [];
-    return {
-      i18nNodes: ml.visitAll(this, nodes),
-      errors: this._errors,
-    };
+  visitAttribute(attribute: ml.Attribute, context: any): any {
+    throw new Error('unreachable code');
  }

-  visitText(text: ml.Text, context: any) { return new i18n.Text(text.value, text.sourceSpan); }
+  visitText(text: ml.Text, context: any): any { return text.value; }

-  visitElement(el: ml.Element, context: any): i18n.Placeholder {
-    if (el.name === _PLACEHOLDER_TAG) {
-      const nameAttr = el.attrs.find((attr) => attr.name === 'id');
-      if (nameAttr) {
-        return new i18n.Placeholder('', nameAttr.value, el.sourceSpan);
-      }
+  visitComment(comment: ml.Comment, context: any): any { return ''; }

-      this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "id" attribute`);
-    } else {
-      this._addError(el, `Unexpected tag`);
-    }
+  visitExpansion(expansion: ml.Expansion, context: any): any {
+    throw new Error('unreachable code');
  }

-  visitExpansion(icu: ml.Expansion, context: any) {}
-
-  visitExpansionCase(icuCase: ml.ExpansionCase, context: any): any {}
-
-  visitComment(comment: ml.Comment, context: any) {}
-
-  visitAttribute(attribute: ml.Attribute, context: any) {}
+  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {
+    throw new Error('unreachable code');
+  }

  private _addError(node: ml.Node, message: string): void {
    this._errors.push(new I18nError(node.sourceSpan, message));
@@ -6,8 +6,9 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {decimalDigest} from '../digest';
+import * as html from '../../ml_parser/ast';
 import * as i18n from '../i18n_ast';
+import {MessageBundle} from '../message_bundle';

 import {Serializer} from './serializer';
 import * as xml from './xml_helper';
@@ -38,19 +39,12 @@ const _DOCTYPE = `<!ELEMENT messagebundle (msg)*>
 <!ELEMENT ex (#PCDATA)>`;

 export class Xmb implements Serializer {
-  write(messages: i18n.Message[]): string {
-    const exampleVisitor = new ExampleVisitor();
+  write(messageMap: {[k: string]: i18n.Message}): string {
    const visitor = new _Visitor();
-    const visited: {[id: string]: boolean} = {};
-    let rootNode = new xml.Tag(_MESSAGES_TAG);
-
-    messages.forEach(message => {
-      const id = this.digest(message);
-
-      // deduplicate messages
-      if (visited[id]) return;
-      visited[id] = true;
+    const rootNode = new xml.Tag(_MESSAGES_TAG);

+    Object.keys(messageMap).forEach((id) => {
+      const message = messageMap[id];
      const attrs: {[k: string]: string} = {id};

      if (message.description) {
@@ -72,16 +66,14 @@ export class Xmb implements Serializer {
      new xml.CR(),
      new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),
      new xml.CR(),
-      exampleVisitor.addDefaultExamples(rootNode),
+      rootNode,
      new xml.CR(),
    ]);
  }

-  load(content: string, url: string): {[msgId: string]: i18n.Node[]} {
+  load(content: string, url: string, messageBundle: MessageBundle): {[id: string]: html.Node[]} {
    throw new Error('Unsupported');
  }
-
-  digest(message: i18n.Message): string { return digest(message); }
 }

 class _Visitor implements i18n.Visitor {
@@ -94,7 +86,7 @@ class _Visitor implements i18n.Visitor {
  }

  visitIcu(icu: i18n.Icu, context?: any): xml.Node[] {
-    const nodes = [new xml.Text(`{${icu.expressionPlaceholder}, ${icu.type}, `)];
+    const nodes = [new xml.Text(`{${icu.expression}, ${icu.type}, `)];

    Object.keys(icu.cases).forEach((c: string) => {
      nodes.push(new xml.Text(`${c} {`), ...icu.cases[c].visit(this), new xml.Text(`} `));
@@ -131,30 +123,3 @@ class _Visitor implements i18n.Visitor {
    return [].concat(...nodes.map(node => node.visit(this)));
  }
 }
-
-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 {}
-}
@@ -7,63 +7,112 @@
 */

 import * as ml from '../../ml_parser/ast';
+import {HtmlParser} from '../../ml_parser/html_parser';
+import {InterpolationConfig} from '../../ml_parser/interpolation_config';
 import {XmlParser} from '../../ml_parser/xml_parser';
+import {ParseError} from '../../parse_util';
 import * as i18n from '../i18n_ast';
+import {MessageBundle} from '../message_bundle';
 import {I18nError} from '../parse_util';

-import {Serializer} from './serializer';
-import {digest} from './xmb';
+import {Serializer, extractPlaceholderToIds, extractPlaceholders} from './serializer';

 const _TRANSLATIONS_TAG = 'translationbundle';
 const _TRANSLATION_TAG = 'translation';
 const _PLACEHOLDER_TAG = 'ph';

 export class Xtb implements Serializer {
-  write(messages: i18n.Message[]): string { throw new Error('Unsupported'); }
+  constructor(private _htmlParser: HtmlParser, private _interpolationConfig: InterpolationConfig) {}

-  load(content: string, url: string): {[msgId: string]: i18n.Node[]} {
-    // xtb to xml nodes
-    const xtbParser = new XtbParser();
-    const {mlNodesByMsgId, errors} = xtbParser.parse(content, url);
+  write(messageMap: {[id: string]: i18n.Message}): string { throw new Error('Unsupported'); }

-    // xml nodes to i18n nodes
-    const i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {};
-    const converter = new XmlToI18n();
-    Object.keys(mlNodesByMsgId).forEach(msgId => {
-      const {i18nNodes, errors: e} = converter.convert(mlNodesByMsgId[msgId]);
-      errors.push(...e);
-      i18nNodesByMsgId[msgId] = i18nNodes;
-    });
+  load(content: string, url: string, messageBundle: MessageBundle): {[id: string]: ml.Node[]} {
+    // Parse the xtb file into xml nodes
+    const result = new XmlParser().parse(content, url);
+
+    if (result.errors.length) {
+      throw new Error(`xtb parse errors:\n${result.errors.join('\n')}`);
+    }
+
+    // Replace the placeholders, messages are now string
+    const {messages, errors} = new _Visitor().parse(result.rootNodes, messageBundle);

    if (errors.length) {
      throw new Error(`xtb parse errors:\n${errors.join('\n')}`);
    }

-    return i18nNodesByMsgId;
-  }
+    // Convert the string messages to html ast
+    // TODO(vicb): map error message back to the original message in xtb
+    const messageMap: {[id: string]: ml.Node[]} = {};
+    const parseErrors: ParseError[] = [];

-  digest(message: i18n.Message): string { return digest(message); }
+    Object.keys(messages).forEach((id) => {
+      const res = this._htmlParser.parse(messages[id], url, true, this._interpolationConfig);
+      parseErrors.push(...res.errors);
+      messageMap[id] = res.rootNodes;
+    });
+
+    if (parseErrors.length) {
+      throw new Error(`xtb parse errors:\n${parseErrors.join('\n')}`);
+    }
+
+    return messageMap;
+  }
 }

-// Extract messages as xml nodes from the xtb file
-class XtbParser implements ml.Visitor {
+class _Visitor implements ml.Visitor {
+  private _messageNodes: [string, ml.Node[]][];
+  private _translatedMessages: {[id: string]: string};
  private _bundleDepth: number;
+  private _translationDepth: number;
  private _errors: I18nError[];
-  private _mlNodesByMsgId: {[msgId: string]: ml.Node[]};
+  private _placeholders: {[name: string]: string};
+  private _placeholderToIds: {[name: string]: string};

-  parse(xtb: string, url: string) {
+  parse(nodes: ml.Node[], messageBundle: MessageBundle):
+      {messages: {[k: string]: string}, errors: I18nError[]} {
+    this._messageNodes = [];
+    this._translatedMessages = {};
    this._bundleDepth = 0;
-    this._mlNodesByMsgId = {};
+    this._translationDepth = 0;
+    this._errors = [];

-    const xml = new XmlParser().parse(xtb, url, true);
+    // Find all messages
+    ml.visitAll(this, nodes, null);

-    this._errors = xml.errors;
-    ml.visitAll(this, xml.rootNodes);
+    const messageMap = messageBundle.getMessageMap();
+    const placeholders = extractPlaceholders(messageBundle);
+    const placeholderToIds = extractPlaceholderToIds(messageBundle);

-    return {
-      mlNodesByMsgId: this._mlNodesByMsgId,
-      errors: this._errors,
-    };
+    this._messageNodes
+        .filter(message => {
+          // Remove any messages that is not present in the source message bundle.
+          return messageMap.hasOwnProperty(message[0]);
+        })
+        .sort((a, b) => {
+          // Because there could be no ICU placeholders inside an ICU message,
+          // we do not need to take into account the `placeholderToMsgIds` of the referenced
+          // messages, those would always be empty
+          // TODO(vicb): overkill - create 2 buckets and [...woDeps, ...wDeps].process()
+          if (Object.keys(messageMap[a[0]].placeholderToMsgIds).length == 0) {
+            return -1;
+          }
+
+          if (Object.keys(messageMap[b[0]].placeholderToMsgIds).length == 0) {
+            return 1;
+          }
+
+          return 0;
+        })
+        .forEach(message => {
+          const id = message[0];
+          this._placeholders = placeholders[id] || {};
+          this._placeholderToIds = placeholderToIds[id] || {};
+          // TODO(vicb): make sure there is no `_TRANSLATIONS_TAG` nor `_TRANSLATION_TAG`
+          this._translatedMessages[id] = ml.visitAll(this, message[1]).join('');
+        });
+
+    return {messages: this._translatedMessages, errors: this._errors};
  }

  visitElement(element: ml.Element, context: any): any {
@@ -78,16 +127,40 @@ class XtbParser implements ml.Visitor {
        break;

      case _TRANSLATION_TAG:
+        this._translationDepth++;
+        if (this._translationDepth > 1) {
+          this._addError(element, `<${_TRANSLATION_TAG}> elements can not be nested`);
+        }
        const idAttr = element.attrs.find((attr) => attr.name === 'id');
        if (!idAttr) {
          this._addError(element, `<${_TRANSLATION_TAG}> misses the "id" attribute`);
        } else {
-          const id = idAttr.value;
-          if (this._mlNodesByMsgId.hasOwnProperty(id)) {
-            this._addError(element, `Duplicated translations for msg ${id}`);
-          } else {
-            this._mlNodesByMsgId[id] = element.children;
+          // ICU placeholders are reference to other messages.
+          // The referenced message might not have been decoded yet.
+          // We need to have all messages available to make sure deps are decoded first.
+          // TODO(vicb): report an error on duplicate id
+          this._messageNodes.push([idAttr.value, element.children]);
+        }
+        this._translationDepth--;
+        break;
+
+      case _PLACEHOLDER_TAG:
+        const nameAttr = element.attrs.find((attr) => attr.name === 'name');
+        if (!nameAttr) {
+          this._addError(element, `<${_PLACEHOLDER_TAG}> misses the "name" attribute`);
+        } else {
+          const name = nameAttr.value;
+          if (this._placeholders.hasOwnProperty(name)) {
+            return this._placeholders[name];
          }
+          if (this._placeholderToIds.hasOwnProperty(name) &&
+              this._translatedMessages.hasOwnProperty(this._placeholderToIds[name])) {
+            return this._translatedMessages[this._placeholderToIds[name]];
+          }
+          // TODO(vicb): better error message for when
+          // !this._translatedMessages.hasOwnProperty(this._placeholderToIds[name])
+          this._addError(
+              element, `The placeholder "${name}" does not exists in the source message`);
        }
        break;

@@ -96,68 +169,23 @@ class XtbParser implements ml.Visitor {
    }
  }

-  visitAttribute(attribute: ml.Attribute, context: any): any {}
+  visitAttribute(attribute: ml.Attribute, context: any): any {
+    throw new Error('unreachable code');
+  }

-  visitText(text: ml.Text, context: any): any {}
+  visitText(text: ml.Text, context: any): any { return text.value; }

-  visitComment(comment: ml.Comment, context: any): any {}
+  visitComment(comment: ml.Comment, context: any): any { return ''; }

-  visitExpansion(expansion: ml.Expansion, context: any): any {}
+  visitExpansion(expansion: ml.Expansion, context: any): any {
+    const strCases = expansion.cases.map(c => c.visit(this, null));

-  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {}
-
-  private _addError(node: ml.Node, message: string): void {
-    this._errors.push(new I18nError(node.sourceSpan, message));
-  }
-}
-
-// Convert ml nodes (xtb syntax) to i18n nodes
-class XmlToI18n implements ml.Visitor {
-  private _errors: I18nError[];
-
-  convert(nodes: ml.Node[]) {
-    this._errors = [];
-    return {
-      i18nNodes: ml.visitAll(this, nodes),
-      errors: this._errors,
-    };
-  }
-
-  visitText(text: ml.Text, context: any) { return new i18n.Text(text.value, text.sourceSpan); }
-
-  visitExpansion(icu: ml.Expansion, context: any) {
-    const caseMap: {[value: string]: i18n.Node} = {};
-
-    ml.visitAll(this, icu.cases).forEach(c => {
-      caseMap[c.value] = new i18n.Container(c.nodes, icu.sourceSpan);
-    });
-
-    return new i18n.Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);
-  }
-
-  visitExpansionCase(icuCase: ml.ExpansionCase, context: any): any {
-    return {
-      value: icuCase.value,
-      nodes: ml.visitAll(this, icuCase.expression),
-    };
-  }
-
-  visitElement(el: ml.Element, context: any): i18n.Placeholder {
-    if (el.name === _PLACEHOLDER_TAG) {
-      const nameAttr = el.attrs.find((attr) => attr.name === 'name');
-      if (nameAttr) {
-        return new i18n.Placeholder('', nameAttr.value, el.sourceSpan);
-      }
-
-      this._addError(el, `<${_PLACEHOLDER_TAG}> misses the "name" attribute`);
-    } else {
-      this._addError(el, `Unexpected tag`);
-    }
-  }
-
-  visitComment(comment: ml.Comment, context: any) {}
-
-  visitAttribute(attribute: ml.Attribute, context: any) {}
+    return `{${expansion.switchValue}, ${expansion.type}, strCases.join(' ')}`;
+  }
+
+  visitExpansionCase(expansionCase: ml.ExpansionCase, context: any): any {
+    return `${expansionCase.value} {${ml.visitAll(this, expansionCase.expression, null)}}`;
+  }

  private _addError(node: ml.Node, message: string): void {
    this._errors.push(new I18nError(node.sourceSpan, message));
@@ -7,120 +7,22 @@
 */

 import * as html from '../ml_parser/ast';
-import {HtmlParser} from '../ml_parser/html_parser';

-import * as i18n from './i18n_ast';
-import {I18nError} from './parse_util';
+import {MessageBundle} from './message_bundle';
 import {Serializer} from './serializers/serializer';

 /**
 * A container for translated messages
 */
 export class TranslationBundle {
-  private _i18nToHtml: I18nToHtmlVisitor;
+  constructor(private _messageMap: {[id: string]: html.Node[]} = {}) {}

-  constructor(
-      private _i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {},
-      public digest: (m: i18n.Message) => string) {
-    this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, digest);
+  static load(content: string, url: string, messageBundle: MessageBundle, serializer: Serializer):
+      TranslationBundle {
+    return new TranslationBundle(serializer.load(content, url, messageBundle));
  }

-  static load(content: string, url: string, serializer: Serializer): TranslationBundle {
-    const i18nNodesByMsgId = serializer.load(content, url);
-    const digestFn = (m: i18n.Message) => serializer.digest(m);
-    return new TranslationBundle(i18nNodesByMsgId, digestFn);
-  }
+  get(id: string): html.Node[] { return this._messageMap[id]; }

-  get(srcMsg: i18n.Message): html.Node[] {
-    const html = this._i18nToHtml.convert(srcMsg);
-
-    if (html.errors.length) {
-      throw new Error(html.errors.join('\n'));
-    }
-
-    return html.nodes;
-  }
-
-  has(srcMsg: i18n.Message): boolean { return this.digest(srcMsg) in this._i18nNodesByMsgId; }
-}
-
-class I18nToHtmlVisitor implements i18n.Visitor {
-  private _srcMsg: i18n.Message;
-  private _srcMsgStack: i18n.Message[] = [];
-  private _errors: I18nError[] = [];
-
-  constructor(
-      private _i18nNodesByMsgId: {[msgId: string]: i18n.Node[]} = {},
-      private _digest: (m: i18n.Message) => string) {}
-
-  convert(srcMsg: i18n.Message): {nodes: html.Node[], errors: I18nError[]} {
-    this._srcMsgStack.length = 0;
-    this._errors.length = 0;
-    // i18n to text
-    const text = this._convertToText(srcMsg);
-
-    // text to html
-    const url = srcMsg.nodes[0].sourceSpan.start.file.url;
-    const html = new HtmlParser().parse(text, url, true);
-
-    return {
-      nodes: html.rootNodes,
-      errors: [...this._errors, ...html.errors],
-    };
-  }
-
-  visitText(text: i18n.Text, context?: any): string { return text.value; }
-
-  visitContainer(container: i18n.Container, context?: any): any {
-    return container.children.map(n => n.visit(this)).join('');
-  }
-
-  visitIcu(icu: i18n.Icu, context?: any): any {
-    const cases = Object.keys(icu.cases).map(k => `${k} {${icu.cases[k].visit(this)}}`);
-
-    // TODO(vicb): Once all format switch to using expression placeholders
-    // we should throw when the placeholder is not in the source message
-    const exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ?
-        this._srcMsg.placeholders[icu.expression] :
-        icu.expression;
-
-    return `{${exp}, ${icu.type}, ${cases.join(' ')}}`;
-  }
-
-  visitPlaceholder(ph: i18n.Placeholder, context?: any): string {
-    const phName = ph.name;
-    if (this._srcMsg.placeholders.hasOwnProperty(phName)) {
-      return this._srcMsg.placeholders[phName];
-    }
-
-    if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) {
-      return this._convertToText(this._srcMsg.placeholderToMessage[phName]);
-    }
-
-    this._addError(ph, `Unknown placeholder`);
-    return '';
-  }
-
-  visitTagPlaceholder(ph: i18n.TagPlaceholder, context?: any): any { throw 'unreachable code'; }
-
-  visitIcuPlaceholder(ph: i18n.IcuPlaceholder, context?: any): any { throw 'unreachable code'; }
-
-  private _convertToText(srcMsg: i18n.Message): string {
-    const digest = this._digest(srcMsg);
-    if (this._i18nNodesByMsgId.hasOwnProperty(digest)) {
-      this._srcMsgStack.push(this._srcMsg);
-      this._srcMsg = srcMsg;
-      const nodes = this._i18nNodesByMsgId[digest];
-      const text = nodes.map(node => node.visit(this)).join('');
-      this._srcMsg = this._srcMsgStack.pop();
-      return text;
-    }
-
-    this._addError(srcMsg.nodes[0], `Missing translation for message ${digest}`);
-    return '';
-  }
-
-  private _addError(el: i18n.Node, msg: string) {
-    this._errors.push(new I18nError(el.sourceSpan, msg));
-  }
+  has(id: string): boolean { return id in this._messageMap; }
 }
@@ -8,8 +8,8 @@

 import {ANALYZE_FOR_ENTRY_COMPONENTS, AnimationTransitionEvent, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, ElementRef, Injector, LOCALE_ID, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT, TemplateRef, ViewContainerRef, ViewEncapsulation} from '@angular/core';

-import {StaticSymbol} from './aot/static_symbol';
-import {CompileIdentifierMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
+import {StaticSymbol, isStaticSymbol} from './aot/static_symbol';
+import {CompileIdentifierMetadata, CompileTokenMetadata} from './compile_metadata';
 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');
@@ -347,25 +347,27 @@ export function assetUrl(pkg: string, path: string = null, type: string = 'src')
 }

 export function resolveIdentifier(identifier: IdentifierSpec) {
-  return reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);
-}
-
-export function createIdentifier(identifier: IdentifierSpec): CompileIdentifierMetadata {
+  let moduleUrl = identifier.moduleUrl;
  const reference =
      reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);
-  return {reference: reference};
+  if (isStaticSymbol(reference)) {
+    moduleUrl = reference.filePath;
+  }
+  return new CompileIdentifierMetadata(
+      {name: identifier.name, moduleUrl: moduleUrl, reference: reference});
 }

 export function identifierToken(identifier: CompileIdentifierMetadata): CompileTokenMetadata {
-  return {identifier: identifier};
+  return new CompileTokenMetadata({identifier: identifier});
 }

-export function createIdentifierToken(identifier: IdentifierSpec): CompileTokenMetadata {
-  return identifierToken(createIdentifier(identifier));
+export function resolveIdentifierToken(identifier: IdentifierSpec): CompileTokenMetadata {
+  return identifierToken(resolveIdentifier(identifier));
 }

-export function createEnumIdentifier(
-    enumType: IdentifierSpec, name: string): CompileIdentifierMetadata {
-  const resolvedEnum = reflector.resolveEnum(resolveIdentifier(enumType), name);
-  return {reference: resolvedEnum};
+export function resolveEnumIdentifier(
+    enumType: CompileIdentifierMetadata, name: string): CompileIdentifierMetadata {
+  const resolvedEnum = reflector.resolveEnum(enumType.reference, name);
+  return new CompileIdentifierMetadata(
+      {name: `${enumType.name}.${name}`, moduleUrl: enumType.moduleUrl, reference: resolvedEnum});
 }
@@ -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/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chuck Jazdzewski	11ed8f56ab	docs(changelog): add changelog for 2.2.2	2016-11-22 14:36:49 -08:00
Chuck Jazdzewski	a49acbf027	chore(release): cut the 2.2.2 release	2016-11-22 14:33:08 -08:00
Chuck Jazdzewski	8e41910429	fix(build): update versions of umd bundles (#13038 ) Fixes #13037	2016-11-22 14:26:20 -08:00
Pete Bacon Darwin	a4ab14bf74	test(upgrade): remove `setTimeout` from lifecycle hook tests (#13027 ) * test(upgrade): remove unnecessary NO_ERRORS_SCHEMA * test(upgrade): remove `setTimeout` from lifecycle hook tests Closes #13019	2016-11-22 14:26:20 -08:00
Matias Niemelä	ea4fc9b421	fix(animations): blend in all previously transitioned styles into next animation if interrupted (#13014 ) Closes #13013 Closes #13014	2016-11-22 14:26:20 -08:00
Brian Michalski	0956acee58	fix(closure): quote date pattern aliases (#13012 ) Quota the pattern aliases to prevent closure renaming. These are quoted in DatePipe and also need to be quoted here.	2016-11-22 14:26:20 -08:00
Chuck Jazdzewski	2ca67e1674	refactor(compiler): allow control of StaticSymbol lifetime (#12986 )	2016-11-22 14:26:20 -08:00
Sammy Jelin	472666fc2b	refactor(ngUpgrade): Small cleanup with Testability API and resumeBootstrap (#12926 ) * With non-static ngUpgrade apps, callbacks to `whenStable` were being invoked with the wrong context * With non-static ngUpgrade apps, `resumeBootstrap` was being run outside the NgZone * Remove redundent `whenStableContext` variable Neither of the first two problems were actually causing bugs (as far as I know), but they might have caused problems in the future. Inspired by https://github.com/angular/angular/pull/12910, but for non-static apps.	2016-11-22 14:26:20 -08:00
Brady Isom	462316b0f1	fix(upgrade): call ng1 lifecycle hooks (#12875 )	2016-11-22 14:26:20 -08:00
Philippe MARTIN	96c2b2cc25	fix(changelog): replace beta.1 with beta.0 (#12961 )	2016-11-22 14:26:19 -08:00
Tobias Bosch	3d407fc010	refactor(compiler): further minor fixes	2016-11-22 14:26:19 -08:00
Tobias Bosch	64bd672e3a	refactor(compiler): Reintroduce `ReflectorHost` and move `Extractor` into `@angular/compiler`	2016-11-22 14:26:19 -08:00
Tobias Bosch	ef38676091	refactor(comiler): various cleanups	2016-11-22 14:26:19 -08:00
Tobias Bosch	38be2b81c6	refactor(compiler): renames - `NgHost` to `CompilerHost` - `AotCompilerHost.resolveFileToImport` to `AotCompilerHost.fileNameToModuleName` - `AotCompilerHoset.resolveImportToFile` to `AotCompilerHost.moduleNameToFileName`	2016-11-22 14:26:19 -08:00
Tobias Bosch	39a71eb0ec	refactor(tsc-wrapped): collect all exported functions and classes and bump metadata version from 1 to 2 This is needed to resolve symbols without `.d.ts` files. This bumps the version of the metadata from 1 to 2. This adds logic into `ng_host.ts` to automatically upgrade version 1 to version 2 metadata by adding the exported symbols from the `.d.ts` file.	2016-11-22 14:26:19 -08:00
Tobias Bosch	2fe6fb1163	fix(compiler): fix versions of `@angular/tsc-wrapped`	2016-11-22 14:26:19 -08:00
Tobias Bosch	b5afe51b26	refactor(compiler): move symbol extraction to `AotCompiler`	2016-11-22 14:26:19 -08:00
Tobias Bosch	170525a225	refactor(compiler): add `createAotCompiler` factory Also adds 2 more methods to the `AotCompilerHost`: - `loadResource` - `resolveFileToImport`	2016-11-22 14:26:19 -08:00
Tobias Bosch	0c98f45105	refactor(compiler): remove `asset:` urls These urls were just relicts from Dart.	2016-11-22 14:26:19 -08:00
Tobias Bosch	e7025c9423	refactor(compiler): move `findDeclaration` into the `StaticReflector` Previously, this was part of the `AotCompilerHost`. The `AotCompilerHost` is now also greatly simplified.	2016-11-22 14:26:18 -08:00
Tobias Bosch	8f295287a2	refactor(compiler): move `static_reflector` into `@angular/compiler` and rename files - `src/runtime_compiler.ts` -> `src/jit/compiler.ts` - `src/compiler.ts` -> `src/jit/compiler_factory.ts` - `src/offline_compiler` -> `src/aot/compiler.ts` Part of #12867	2016-11-22 14:26:18 -08:00
Chuck Jazdzewski	030facc66a	chore(build): update package.json versions during build (#12957 )	2016-11-22 14:26:18 -08:00
Alex Eagle	45af8f6752	fix(ci): pin version of npm on CircleCI (#12954 )	2016-11-22 14:26:18 -08:00
Tobias Bosch	33a79028be	fix(benchmarks): use sanitized style values (#12943 )	2016-11-22 14:26:18 -08:00
vsavkin	09226d96f8	fix(router): support redirects to named outlets Closes #12740, #9921	2016-11-22 14:26:18 -08:00
Chuck Jazdzewski	6c3166e6e4	chore(release): cut the 2.3.0-beta.0 realse and add change log	2016-11-22 14:26:18 -08:00
Victor Savkin	8df328b15a	fix(router): add a banner file for the router (#12919 )	2016-11-22 14:26:17 -08:00
vsavkin	115f18fa06	fix(router): removes a peer dependency from router to upgrade	2016-11-22 14:26:16 -08:00
Victor Savkin	511cd4d182	fix(router): add a banner file for the router (#12919 )	2016-11-22 14:26:14 -08:00
vsavkin	87d5d49530	fix(router): removes a peer dependency from router to upgrade	2016-11-22 14:26:14 -08:00
Chuck Jazdzewski	933caacad3	chore(release): cut angular 2.2.1	2016-11-16 16:38:28 -08:00
Chuck Jazdzewski	efe9c4f35c	fix(tools): fix error when running test.sh (#12927 )	2016-11-16 16:26:44 -08:00
Chuck Jazdzewski	5b0f9e2f51	refactor(compiler): allows synchronous retrieving of metadata (#12908 ) Allows non-normalized metadata to be retrieved synchronously. Related to #7482	2016-11-16 16:26:44 -08:00
Tobias Bosch	462879887a	fix(core): support `ngTemplateOutlet` in production mode (#12921 ) Fixes #12911	2016-11-16 16:26:44 -08:00
Peter Bacon Darwin	dae0d0fd66	docs(upgrade/static): improve API docs with examples Closes #12717	2016-11-16 16:26:44 -08:00
Peter Bacon Darwin	c7f750dd5a	chore(public_api): remove Angular 1 types from upgrade/static API	2016-11-16 16:26:44 -08:00
Peter Bacon Darwin	73de925551	chore(examples): add upgrade/static example	2016-11-16 16:26:44 -08:00
Peter Bacon Darwin	547c22029a	chore(examples): support upgrade/static examples	2016-11-16 16:26:44 -08:00
Victor Savkin	364642d58c	fix(router): add a banner file for the router (#12919 )	2016-11-16 16:26:44 -08:00
Dzmitry Shylovich	7b67badc43	fix(platform_browser): fix disableDebugTools() (#12918 )	2016-11-16 16:26:44 -08:00
Sammy Jelin	dc1662a447	fix(ngUpgrade): make AoT ngUpgrade work with the testability API and resumeBootstrap() (#12910 )	2016-11-16 16:26:43 -08:00
Igor Minar	b5f433626b	build(build.sh): echo before building examples	2016-11-16 16:26:43 -08:00
Victor Savkin	dabaf858d9	fix(router): should not create a route state if navigation is canceled (#12868 ) Closes #12776	2016-11-16 16:26:43 -08:00
Dzmitry Shylovich	bbc3c9ce0e	refactor(forms): remove facade (#12558 )	2016-11-16 16:26:43 -08:00
vsavkin	1dcf1f484e	fix(router): removes a peer dependency from router to upgrade	2016-11-16 16:26:43 -08:00
Matias Niemelä	583d2833db	fix(animations): only pass in same typed players as previous players into web-animations (#12907 ) Closes #12907	2016-11-16 16:26:43 -08:00
Dzmitry Shylovich	f502a768d3	chore(router): remove @angular/upgrade peer dep (#12896 )	2016-11-16 16:26:43 -08:00
João Dias	16303ac487	refactor(http): remove all facade methods from http module (#12870 )	2016-11-16 16:26:43 -08:00
Alex Eagle	6cdc3b5c12	fix(tsickle): support ctorParams in function closure (#12876 ) See https://github.com/angular/tsickle/issues/261 for context.	2016-11-16 16:26:43 -08:00
Matias Niemelä	5c46c493f2	fix(animations): retain styling when transition destinations are changed (#12208 ) Closes #9661 Closes #12208	2016-11-16 16:26:43 -08:00
Dzmitry Shylovich	e02c18049d	fix(select): allow for null values in HTML select options bound with ngValue closes #12829	2016-11-16 16:26:43 -08:00
Craig Hutchison	e0ce5458a2	fix: allow for null values in HTML select options bound with ngValue This corrects the case of <option [ngValue]="null"> binding a string like "{0: null}" to the model instead of an actual null object. Closes #10349	2016-11-16 16:26:43 -08:00
Craig Hutchison	6a5ba0ec81	fix: allow for null values in HTML select options bound with ngValue This corrects the case of <option [ngValue]="null"> binding a string like "{0: null}" to the model instead of an actual null object. Closes #10349	2016-11-16 16:26:42 -08:00
Victor Berchet	828c0d24eb	refactor(core): remove dead code (#12871 )	2016-11-16 16:26:42 -08:00
Victor Berchet	22536442d6	refactor(core): remove ListWrapper from i18n	2016-11-16 16:26:42 -08:00
Dzmitry Shylovich	845ea235ee	fix(http): return request url if it cannot be retrieved from response closes #12837	2016-11-16 16:26:42 -08:00
Dzmitry Shylovich	21a4de999b	fix(http): correctly handle response body for 204 status code closes #12830 fixes #12393	2016-11-16 16:26:42 -08:00
Dzmitry Shylovich	82b34838bf	refactor(xhr_backend): remove facade	2016-11-16 16:26:42 -08:00