fix(form): fix merge errors

This change retracts support for metadata version 2.

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

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

CHANGELOG.md

@@ -1,16 +1,149 @@
-<a name="2.3.0-beta.1"></a>
-# [2.3.0-beta.1](https://github.com/angular/angular/compare/2.3.0-beta.0...2.3.0-beta.1) (2016-11-22)
+<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
 
-Note: The 2.3.0-beta.1 release also contains all the changes present in the 2.2.2 release.
+* **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)
+* **dom_adapter:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
+* **forms:** ensure `select[multiple]` retains selections ([b3dcff0](https://github.com/angular/angular/commit/b3dcff0)), closes [#12527](https://github.com/angular/angular/issues/12527) [#12654](https://github.com/angular/angular/issues/12654)
+* **forms:** fix Validators.min/maxLength with FormArray ([#13095](https://github.com/angular/angular/issues/13095)) ([7383e4a](https://github.com/angular/angular/commit/7383e4a)), closes [#13089](https://github.com/angular/angular/issues/13089)
+* **forms:** introduce checkbox required validator ([124267c](https://github.com/angular/angular/commit/124267c)), closes [#11459](https://github.com/angular/angular/issues/11459) [#13364](https://github.com/angular/angular/issues/13364)
+* **http:** check response body text against undefined ([#13017](https://github.com/angular/angular/issues/13017)) ([f106a18](https://github.com/angular/angular/commit/f106a18))
+* **http:** create a copy of headers when merge options ([#13365](https://github.com/angular/angular/issues/13365)) ([65c9b5b](https://github.com/angular/angular/commit/65c9b5b)), closes [#11980](https://github.com/angular/angular/issues/11980)
+* **language-service:** correctly type `undefined` ([0a7364f](https://github.com/angular/angular/commit/0a7364f)), closes [#13412](https://github.com/angular/angular/issues/13412) [#13414](https://github.com/angular/angular/issues/13414)
+* Better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
+* Better instructions on running examples and their tests ([203cc7e](https://github.com/angular/angular/commit/203cc7e))
+* **language-service:** treat string unions as strings ([#13406](https://github.com/angular/angular/issues/13406)) ([14dd2b3](https://github.com/angular/angular/commit/14dd2b3)), closes [#13403](https://github.com/angular/angular/issues/13403)
+* **router:** add support for query params with multiple values ([e4d5a5f](https://github.com/angular/angular/commit/e4d5a5f)), closes [#11373](https://github.com/angular/angular/issues/11373)
+* **router:** Use T type in Resolve interface ([#13242](https://github.com/angular/angular/issues/13242)) ([5ee8155](https://github.com/angular/angular/commit/5ee8155))
+* **selector:** SelectorMatcher match elements with :not selector ([#12977](https://github.com/angular/angular/issues/12977)) ([392c9ac](https://github.com/angular/angular/commit/392c9ac))
+* **tsc-wrapped:** generate metadata for exports without module specifier ([cd03c77](https://github.com/angular/angular/commit/cd03c77)), closes [#13327](https://github.com/angular/angular/issues/13327)
+* **upgrade:** fix downgrade content projection and injector inheritance ([86c5098](https://github.com/angular/angular/commit/86c5098)), closes [#6629](https://github.com/angular/angular/issues/6629) [#7727](https://github.com/angular/angular/issues/7727) [#8729](https://github.com/angular/angular/issues/8729) [#9643](https://github.com/angular/angular/issues/9643) [#9649](https://github.com/angular/angular/issues/9649) [#12675](https://github.com/angular/angular/issues/12675)
+
 
 ### Features
 
+* **upgrade:** enable Angular 1 unit testing of upgrade module ([2fc0560](https://github.com/angular/angular/commit/2fc0560)), closes [#5462](https://github.com/angular/angular/issues/5462) [#12675](https://github.com/angular/angular/issues/12675)
+
+
+### 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)
+
+
+<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)
 
@@ -52,6 +185,8 @@ Note: The 2.3.0-beta.1 release also contains all the changes present in the 2.2.
 
 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)
 
@@ -873,7 +1008,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`.
-  - `AplicationRef.registerDisposeListener` is deprecated.
+  - `ApplicationRef.registerDisposeListener` is deprecated.
     Use the `ngOnDestroy` lifecycle hook for providers or
     `NgModuleRef.onDestroy` instead.
   - `disposePlatform` is deprecated. Use `destroyPlatform` instead.

CONTRIBUTING.md

@@ -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 demostrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demostrating 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 demonstrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demonstrating 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/javascriptguide.xml
+[js-style-guide]: https://google.github.io/styleguide/jsguide.html
 [jsfiddle]: http://jsfiddle.net
 [plunker]: http://plnkr.co/edit
 [runnable]: http://runnable.com

DEVELOPER.md

@@ -126,7 +126,7 @@ $ gulp public-api:update
 
 Note: The command `./test.sh tools` fails when the API doesn't match the golden files.
 
-## Formatting your source code
+## <a name="clang-format"></a> 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.

TRIAGE_AND_LABELS.md

@@ -24,8 +24,9 @@ with it.
 * `comp: forms`: `@kara`
 * `comp: http`: `@jeffbcross`
 * `comp: i18n`: `@vicb`
+* `comp: language service`: `@chuckjaz`
 * `comp: metadata-extractor`: `@chuckjaz`
-* `comp: router`: `@vsavkin`
+* `comp: router`: `@vicb`
 * `comp: testing`: `@juliemr`
 * `comp: upgrade`: `@mhevery`
 * `comp: web-worker`: `@vicb`

browser-providers.conf.js

@@ -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: 'BS', required: false}, e2e: {target: null, required: true}},
+  'iOS10': {unitTest: {target: 'SL', 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: '52'},
+  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '54'},
   'SL_CHROMEBETA': {base: 'SauceLabs', browserName: 'chrome', version: 'beta'},
   'SL_CHROMEDEV': {base: 'SauceLabs', browserName: 'chrome', version: 'dev'},
-  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '46'},
+  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '50'},
   '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.0',
+    browser_version: '10.1',
     os: 'Windows',
     os_version: '8'
   },

build.sh

@@ -145,6 +145,11 @@ 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

karma-js.conf.js

@@ -48,13 +48,15 @@ module.exports = function(config) {
 
     exclude: [
       'dist/all/@angular/**/e2e_test/**',
-      'dist/all/@angular/router/**',
+      'dist/all/@angular/**/*node_only_spec.js',
+      'dist/all/@angular/benchpress/**',
       'dist/all/@angular/compiler-cli/**',
       'dist/all/@angular/compiler/test/aot/**',
-      'dist/all/@angular/benchpress/**',
+      'dist/all/@angular/examples/**/e2e_test/*',
       'dist/all/@angular/language-service/**',
-      'dist/all/angular1_router.js',
+      'dist/all/@angular/router/**',
       'dist/all/@angular/platform-browser/testing/e2e_util.js',
+      'dist/all/angular1_router.js',
       'dist/examples/**/e2e_test/**',
     ],
 

modules/@angular/benchpress/package.json

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

modules/@angular/benchpress/test/firefox_extension/spec.ts

@@ -6,6 +6,7 @@
  * 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) {

modules/@angular/common/index.ts

@@ -11,9 +11,6 @@
  * @description
  * Entry point for all public APIs of the common package.
  */
-export * from './src/location';
-export {NgLocalization} from './src/localization';
-export {CommonModule} from './src/common_module';
+export * from './src/common';
 
-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';
+// This file only reexports content of the `src` folder. Keep it that way.

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

@@ -0,0 +1,20 @@
+/**
+ * @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';

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

@@ -23,9 +23,23 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
  */
 export function getPluralCategory(
     value: number, cases: string[], ngLocalization: NgLocalization): string {
-  const nbCase = `=${value}`;
+  let key = `=${value}`;
 
-  return cases.indexOf(nbCase) > -1 ? nbCase : ngLocalization.getPluralCategory(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}"`);
 }
 
 /**

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

@@ -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 './location/platform_location';
-export * from './location/location_strategy';
-export * from './location/hash_location_strategy';
-export * from './location/path_location_strategy';
-export * from './location/location';

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

@@ -17,6 +17,8 @@ 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)
@@ -27,18 +29,7 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';
  *
  * ### Example
  *
- * ```
- * import {Component, NgModule} from '@angular/core';
- * import {
- *   LocationStrategy,
- *   HashLocationStrategy
- * } from '@angular/common';
- *
- * @NgModule({
- *   providers: [{provide: LocationStrategy, useClass: HashLocationStrategy}]
- * })
- * class AppModule {}
- * ```
+ * {@example common/location/ts/hash_location_component.ts region='LocationComponent'}
  *
  * @stable
  */

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

@@ -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 './platform_location';
+export * from './location_strategy';
+export * from './hash_location_strategy';
+export * from './path_location_strategy';
+export * from './location';

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

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

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

@@ -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} (default).
+ * {@link HashLocationStrategy} and {@link PathLocationStrategy}.
  *
  * This is used under the hood of the {@link Location} service.
  *

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

@@ -17,14 +17,13 @@ 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.
@@ -37,6 +36,10 @@ 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()

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

@@ -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 continuesly updates the view with the current time.
+ * to the view. The Observable continuously updates the view with the current time.
  *
  * {@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}
  *

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

@@ -7,11 +7,14 @@
  */
 
 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.

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

@@ -44,6 +44,7 @@ const DATE_FORMATS_SPLIT =
     /((?:[^yMLdHhmsazZEwGjJ']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|L+|d+|H+|h+|J+|j+|m+|s+|a|z|Z|G+|w+))(.*)/;
 
 const PATTERN_ALIASES: {[format: string]: DateFormatterFn} = {
+  // Keys are quoted so they do not get renamed during closure compilation.
   'yMMMdjms': datePartGetterFactory(combine([
     digitCondition('year', 1),
     nameCondition('month', 3),
@@ -72,48 +73,50 @@ const PATTERN_ALIASES: {[format: string]: DateFormatterFn} = {
 };
 
 const DATE_FORMATS: {[format: string]: DateFormatterFn} = {
-  yyyy: datePartGetterFactory(digitCondition('year', 4)),
-  yy: datePartGetterFactory(digitCondition('year', 2)),
-  y: datePartGetterFactory(digitCondition('year', 1)),
-  MMMM: datePartGetterFactory(nameCondition('month', 4)),
-  MMM: datePartGetterFactory(nameCondition('month', 3)),
-  MM: datePartGetterFactory(digitCondition('month', 2)),
-  M: datePartGetterFactory(digitCondition('month', 1)),
-  LLLL: datePartGetterFactory(nameCondition('month', 4)),
-  L: datePartGetterFactory(nameCondition('month', 1)),
-  dd: datePartGetterFactory(digitCondition('day', 2)),
-  d: datePartGetterFactory(digitCondition('day', 1)),
-  HH: digitModifier(
+  // Keys are quoted so they do not get renamed.
+  'yyyy': datePartGetterFactory(digitCondition('year', 4)),
+  'yy': datePartGetterFactory(digitCondition('year', 2)),
+  'y': datePartGetterFactory(digitCondition('year', 1)),
+  'MMMM': datePartGetterFactory(nameCondition('month', 4)),
+  'MMM': datePartGetterFactory(nameCondition('month', 3)),
+  'MM': datePartGetterFactory(digitCondition('month', 2)),
+  'M': datePartGetterFactory(digitCondition('month', 1)),
+  'LLLL': datePartGetterFactory(nameCondition('month', 4)),
+  'L': datePartGetterFactory(nameCondition('month', 1)),
+  'dd': datePartGetterFactory(digitCondition('day', 2)),
+  'd': datePartGetterFactory(digitCondition('day', 1)),
+  'HH': digitModifier(
       hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 2), false)))),
-  H: hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), false))),
-  hh: digitModifier(
+  'H': hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), false))),
+  'hh': digitModifier(
       hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 2), true)))),
-  h: hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
-  jj: datePartGetterFactory(digitCondition('hour', 2)),
-  j: datePartGetterFactory(digitCondition('hour', 1)),
-  mm: digitModifier(datePartGetterFactory(digitCondition('minute', 2))),
-  m: datePartGetterFactory(digitCondition('minute', 1)),
-  ss: digitModifier(datePartGetterFactory(digitCondition('second', 2))),
-  s: datePartGetterFactory(digitCondition('second', 1)),
+  'h': hourExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
+  'jj': datePartGetterFactory(digitCondition('hour', 2)),
+  'j': datePartGetterFactory(digitCondition('hour', 1)),
+  'mm': digitModifier(datePartGetterFactory(digitCondition('minute', 2))),
+  'm': datePartGetterFactory(digitCondition('minute', 1)),
+  'ss': digitModifier(datePartGetterFactory(digitCondition('second', 2))),
+  's': datePartGetterFactory(digitCondition('second', 1)),
   // while ISO 8601 requires fractions to be prefixed with `.` or `,`
   // we can be just safely rely on using `sss` since we currently don't support single or two digit
   // fractions
-  sss: datePartGetterFactory(digitCondition('second', 3)),
-  EEEE: datePartGetterFactory(nameCondition('weekday', 4)),
-  EEE: datePartGetterFactory(nameCondition('weekday', 3)),
-  EE: datePartGetterFactory(nameCondition('weekday', 2)),
-  E: datePartGetterFactory(nameCondition('weekday', 1)),
-  a: hourClockExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
-  Z: timeZoneGetter('short'),
-  z: timeZoneGetter('long'),
-  ww: datePartGetterFactory({}),  // Week of year, padded (00-53). Week 01 is the week with the
-                                  // first Thursday of the year. not support ?
-  w: datePartGetterFactory({}),   // Week of year (0-53). Week 1 is the week with the first Thursday
+  'sss': datePartGetterFactory(digitCondition('second', 3)),
+  'EEEE': datePartGetterFactory(nameCondition('weekday', 4)),
+  'EEE': datePartGetterFactory(nameCondition('weekday', 3)),
+  'EE': datePartGetterFactory(nameCondition('weekday', 2)),
+  'E': datePartGetterFactory(nameCondition('weekday', 1)),
+  'a': hourClockExtractor(datePartGetterFactory(hour12Modify(digitCondition('hour', 1), true))),
+  'Z': timeZoneGetter('short'),
+  'z': timeZoneGetter('long'),
+  'ww': datePartGetterFactory({}),  // Week of year, padded (00-53). Week 01 is the week with the
+                                    // first Thursday of the year. not support ?
+  'w':
+      datePartGetterFactory({}),  // Week of year (0-53). Week 1 is the week with the first Thursday
                                   // of the year not support ?
-  G: datePartGetterFactory(nameCondition('era', 1)),
-  GG: datePartGetterFactory(nameCondition('era', 2)),
-  GGG: datePartGetterFactory(nameCondition('era', 3)),
-  GGGG: datePartGetterFactory(nameCondition('era', 4))
+  'G': datePartGetterFactory(nameCondition('era', 1)),
+  'GG': datePartGetterFactory(nameCondition('era', 2)),
+  'GGG': datePartGetterFactory(nameCondition('era', 3)),
+  'GGGG': datePartGetterFactory(nameCondition('era', 4))
 };
 
 
@@ -184,7 +187,8 @@ function dateFormatter(format: string, date: Date, locale: string): string {
 
   if (fn) return fn(date, locale);
 
-  let parts = DATE_FORMATTER_CACHE.get(format);
+  const cacheKey = format;
+  let parts = DATE_FORMATTER_CACHE.get(cacheKey);
 
   if (!parts) {
     parts = [];
@@ -202,7 +206,7 @@ function dateFormatter(format: string, date: Date, locale: string): string {
       }
     }
 
-    DATE_FORMATTER_CACHE.set(format, parts);
+    DATE_FORMATTER_CACHE.set(cacheKey, parts);
   }
 
   return parts.reduce((text, part) => {

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

@@ -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+))?)?$/;

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @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');

modules/@angular/common/test/localization_spec.ts

@@ -7,13 +7,10 @@
  */
 
 import {LOCALE_ID} from '@angular/core';
-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 {TestBed, inject} from '@angular/core/testing';
 
 import {NgLocaleLocalization, NgLocalization, getPluralCategory} from '../src/localization';
 
-
 export function main() {
   describe('l10n', () => {
 
@@ -141,6 +138,23 @@ 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"');
+        });
+      });
     });
   });
 }

modules/@angular/compiler-cli/index.ts

@@ -5,10 +5,13 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-
 export {AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol} from '@angular/compiler';
 export {CodeGenerator} from './src/codegen';
-export {CompilerHost, CompilerHostContext, NodeCompilerHostContext} from './src/compiler_host';
+export {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter, 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'

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

@@ -0,0 +1,3 @@
+:host {
+  background-color: blue;
+}

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Component, ViewEncapsulation} from '@angular/core';
+
+
+@Component({
+  selector: 'app-root',
+  templateUrl: 'app.component.html',
+  styleUrls: ['app.component.css'],
+  encapsulation: ViewEncapsulation.None
+})
+export class AppComponent {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/app.module.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/feature/feature.module.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/feature/lazy-feature.module.ts

@@ -0,0 +1,24 @@
+/**
+ * @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 {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/feature2/default.module.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/feature2/feature2.module.ts

@@ -0,0 +1,26 @@
+/**
+ * @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 {
+}

modules/@angular/compiler-cli/integrationtest/ngtools_src/lazy.module.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 {}

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

@@ -0,0 +1,19 @@
+{
+  "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": "."
+  }
+}

modules/@angular/compiler-cli/integrationtest/src/module.ts

@@ -11,7 +11,9 @@ import {FormsModule} from '@angular/forms';
 import {ServerModule} from '@angular/platform-server';
 import {MdButtonModule} from '@angular2-material/button';
 
-import {ThirdpartyModule} from '../third_party_src/module';
+// 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 {MultipleComponentsMyComp, NextComp} from './a/multiple_components';
 import {AnimateCmp} from './animate';
@@ -19,7 +21,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, SomePipeInRootModule, SomeService, someLibModuleWithProviders} from './module_fixtures';
+import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomeLibModule, SomePipeInRootModule, SomeService} from './module_fixtures';
 import {CompWithNgContent, ProjectingComp} from './projection';
 import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, DirectiveForQuery} from './queries';
 
@@ -52,7 +54,7 @@ import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, Directive
     FormsModule,
     MdButtonModule,
     ModuleUsingCustomElements,
-    someLibModuleWithProviders(),
+    SomeLibModule.withProviders(),
     ThirdpartyModule,
   ],
   providers: [SomeService],

modules/@angular/compiler-cli/integrationtest/src/module_fixtures.ts

@@ -63,17 +63,13 @@ export function provideValueWithEntryComponents(value: any) {
   entryComponents: [CompUsingLibModuleDirectiveAndPipe],
 })
 export class SomeLibModule {
-}
-
-// 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}])
-    ]
-  };
+  static withProviders() {
+    return {
+      ngModule: SomeLibModule,
+      providers: [
+        ServiceUsingLibModule, provideValueWithEntryComponents(
+                                   [{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
+      ]
+    };
+  }
 }

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

@@ -0,0 +1,158 @@
+#!/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(() => 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);
+      return delegateHost.writeFile.call(delegateHost, fileName, ...rest);
+    }
+  });
+  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 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();

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

@@ -0,0 +1,100 @@
+#!/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[] = [];
+
+  class AssertingHostContext extends NodeCompilerHostContext {
+    readFile(fileName: string): string {
+      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) => new AssertingHostContext())
+      .then((exitCode: any) => {
+        console.log(`>>> codegen done, asserting read files`);
+        assertSomeFileMatch(readFiles, /^node_modules\/.*\.ngsummary\.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(`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')}`);
+}
+
+main();

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

@@ -21,6 +21,8 @@
     "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",

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

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

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

@@ -17,12 +17,13 @@ import {readFileSync} from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost, CompilerHostContext} from './compiler_host';
+import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
 import {PathMappedCompilerHost} from './path_mapped_compiler_host';
 import {Console} from './private_import_core';
 
-const GENERATED_FILES = /\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
-const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
+const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
+const GENERATED_META_FILES = /\.json$/;
+const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;
 
 const PREAMBLE = `/**
  * @fileoverview This file is generated by the Angular 2 template compiler.
@@ -44,7 +45,7 @@ export class CodeGenerator {
     let root = this.options.basePath;
     for (const eachRootDir of this.options.rootDirs || []) {
       if (this.options.trace) {
-        console.log(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
+        console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
       }
       if (path.relative(eachRootDir, filePath).indexOf('.') !== 0) {
         root = eachRootDir;
@@ -68,10 +69,11 @@ export class CodeGenerator {
             sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)))
         .then(generatedModules => {
           generatedModules.forEach(generatedModule => {
-            const sourceFile = this.program.getSourceFile(generatedModule.fileUrl);
-            const emitPath = this.calculateEmitPath(generatedModule.moduleUrl);
-            this.host.writeFile(
-                emitPath, PREAMBLE + generatedModule.source, false, () => {}, [sourceFile]);
+            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]);
           });
         });
   }
@@ -82,9 +84,9 @@ export class CodeGenerator {
       ngCompilerHost?: CompilerHost): CodeGenerator {
     if (!ngCompilerHost) {
       const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      ngCompilerHost = usePathMapping ?
-          new PathMappedCompilerHost(program, tsCompilerHost, options, compilerHostContext) :
-          new CompilerHost(program, tsCompilerHost, options, compilerHostContext);
+      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
+      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
+                                        new CompilerHost(program, options, context);
     }
     const transFile = cliOptions.i18nFile;
     const locale = cliOptions.locale;

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

@@ -15,32 +15,27 @@ 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|css(\.shim)?)$/;
+const IS_GENERATED = /\.(ngfactory|ngstyle)$/;
 
-export interface CompilerHostContext {
-  fileExists(fileName: string): boolean;
-  directoryExists(directoryName: string): boolean;
-  readFile(fileName: string): string;
+export interface CompilerHostContext extends ts.ModuleResolutionHost {
   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[]>();
 
   constructor(
-      protected program: ts.Program, protected compilerHost: ts.CompilerHost,
-      protected options: AngularCompilerOptions, context?: CompilerHostContext) {
+      protected program: ts.Program, protected options: AngularCompilerOptions,
+      protected 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('..');
   }
@@ -81,7 +76,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.compilerHost.fileExists(importedFile)) {
+    if (!this.context.fileExists(importedFile)) {
       this.context.assumeFileExists(importedFile);
     }
 
@@ -181,29 +176,32 @@ export class CompilerHost implements AotCompilerHost {
       const metadatas = metadataOrMetadatas ?
           (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
           [];
-      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
+      const v1Metadata = metadatas.find((m: any) => m['version'] === 1);
+      let v3Metadata = metadatas.find((m: any) => m['version'] === 3);
+      if (!v3Metadata && v1Metadata) {
+        // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
         // as the only difference between the versions is whether all exports are contained in
-        // the metadata
-        v2Metadata = {'__symbolic': 'module', 'version': 2, 'metadata': {}};
+        // the metadata and the `extends` clause.
+        v3Metadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
         if (v1Metadata.exports) {
-          v2Metadata.exports = v1Metadata.exports;
+          v3Metadata.exports = v1Metadata.exports;
         }
         for (let prop in v1Metadata.metadata) {
-          v2Metadata.metadata[prop] = v1Metadata.metadata[prop];
+          v3Metadata.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];
+            if (!v3Metadata.metadata[prop]) {
+              v3Metadata.metadata[prop] = exports.metadata[prop];
             }
           }
+          if (exports.exports) {
+            v3Metadata.exports = exports.exports;
+          }
         }
-        metadatas.push(v2Metadata);
+        metadatas.push(v3Metadata);
       }
       this.resolverCache.set(filePath, metadatas);
       return metadatas;
@@ -214,17 +212,52 @@ export class CompilerHost implements AotCompilerHost {
   }
 
   loadResource(filePath: string): Promise<string> { return this.context.readResource(filePath); }
+
+  loadSummary(filePath: string): string { return this.context.readFile(filePath); }
+
+  getOutputFileName(sourceFilePath: string): string {
+    return sourceFilePath.replace(EXT, '') + '.d.ts';
+  }
 }
 
-export class NodeCompilerHostContext implements CompilerHostContext {
-  constructor(private host: ts.CompilerHost) {}
+export class CompilerHostContextAdapter {
+  protected assumedExists: {[fileName: string]: boolean} = {};
 
-  private assumedExists: {[fileName: string]: boolean} = {};
+  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);
+    }
+  }
 
   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();
@@ -236,12 +269,10 @@ export class NodeCompilerHostContext implements CompilerHostContext {
   readFile(fileName: string): string { return fs.readFileSync(fileName, 'utf8'); }
 
   readResource(s: string) {
-    if (!this.host.fileExists(s)) {
+    if (!this.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));
+    return Promise.resolve(this.readFile(s));
   }
-
-  assumeFileExists(fileName: string): void { this.assumedExists[fileName] = true; }
 }

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

@@ -18,7 +18,7 @@ import * as tsc from '@angular/tsc-wrapped';
 import * as ts from 'typescript';
 
 import {excludeFilePattern} from './codegen';
-import {CompilerHost} from './compiler_host';
+import {CompilerHost, ModuleResolutionHostAdapter} from './compiler_host';
 
 export class Extractor {
   constructor(
@@ -32,8 +32,10 @@ export class Extractor {
 
   static create(
       options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
-      tsCompilerHost: ts.CompilerHost, ngCompilerHost?: CompilerHost): Extractor {
-    if (!ngCompilerHost) ngCompilerHost = new CompilerHost(program, tsCompilerHost, options);
+      moduleResolverHost: ts.ModuleResolutionHost, ngCompilerHost?: CompilerHost): Extractor {
+    if (!ngCompilerHost)
+      ngCompilerHost =
+          new CompilerHost(program, options, new ModuleResolutionHostAdapter(moduleResolverHost));
     const {extractor: ngExtractor} = compiler.Extractor.create(
         ngCompilerHost, {excludeFilePattern: excludeFilePattern(options)});
     return new Extractor(ngExtractor, ngCompilerHost, program);

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

@@ -22,14 +22,25 @@ 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) {
+      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));
-  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);
-  });
+  main(args).then((exitCode: number) => process.exit(exitCode));
 }

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

@@ -0,0 +1,124 @@
+/**
+ * @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} 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 {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; }
+
+
+/**
+ * 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 staticReflector = new StaticReflector(ngCompilerHost);
+    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;
+        },
+        {});
+  }
+}

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

@@ -0,0 +1,205 @@
+/**
+ * @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;
+    }
+  }, []);
+}

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

@@ -25,10 +25,8 @@ const DTS = /\.d\.ts$/;
  * loader what to do.
  */
 export class PathMappedCompilerHost extends CompilerHost {
-  constructor(
-      program: ts.Program, compilerHost: ts.CompilerHost, options: AngularCompilerOptions,
-      context?: CompilerHostContext) {
-    super(program, compilerHost, options, context);
+  constructor(program: ts.Program, options: AngularCompilerOptions, context: CompilerHostContext) {
+    super(program, options, context);
   }
 
   getCanonicalFileName(fileName: string): string {
@@ -56,7 +54,7 @@ export class PathMappedCompilerHost extends CompilerHost {
           ts.resolveModuleName(m, rootedContainingFile, this.options, this.context).resolvedModule;
       if (resolved) {
         if (this.options.traceResolution) {
-          console.log('resolve', m, containingFile, '=>', resolved.resolvedFileName);
+          console.error('resolve', m, containingFile, '=>', resolved.resolvedFileName);
         }
         return this.getCanonicalFileName(resolved.resolvedFileName);
       }
@@ -71,7 +69,7 @@ export class PathMappedCompilerHost extends CompilerHost {
    */
   fileNameToModuleName(importedFile: string, containingFile: string): string {
     if (this.options.traceResolution) {
-      console.log(
+      console.error(
           'getImportPath from containingFile', containingFile, 'to importedFile', importedFile);
     }
 
@@ -119,7 +117,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.compilerHost.fileExists(rootedPath)) {
+      if (!this.context.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).

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @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');

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

@@ -14,14 +14,13 @@ 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));
-    host = new MockCompilerHost(context);
+    const host = new MockCompilerHost(context);
     program = ts.createProgram(
         ['main.ts'], {
           module: ts.ModuleKind.CommonJS,
@@ -33,7 +32,7 @@ describe('CompilerHost', () => {
       throw new Error('Expected no errors');
     }
     hostNestedGenDir = new CompilerHost(
-        program, host, {
+        program, {
           genDir: '/tmp/project/src/gen/',
           basePath: '/tmp/project/src',
           skipMetadataEmit: false,
@@ -43,7 +42,7 @@ describe('CompilerHost', () => {
         },
         context);
     hostSiblingGenDir = new CompilerHost(
-        program, host, {
+        program, {
           genDir: '/tmp/project/gen',
           basePath: '/tmp/project/src/',
           skipMetadataEmit: false,
@@ -67,11 +66,14 @@ 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.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css');
+                 '/tmp/project/src/my.other.css.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
+          .toEqual('../my.other.css.ngstyle');
       expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.css.shim');
+                 '/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');
     });
 
     it('should import application from factory', () => {
@@ -84,6 +86,12 @@ 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');
     });
   });
 
@@ -158,12 +166,18 @@ describe('CompilerHost', () => {
     expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/missing.d.ts')).toBeUndefined();
   });
 
-  it('should add missing v2 metadata from v1 metadata and .d.ts files', () => {
+  it('should add missing v3 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: 2,
-        metadata: {foo: {__symbolic: 'class'}, bar: {__symbolic: 'class'}}
+        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']}],
       }
     ]);
   });
@@ -198,7 +212,17 @@ const FILES: Entry = {
         }
       },
       'metadata_versions': {
-        'v1.d.ts': 'export declare class bar {}',
+        '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.metadata.json':
             `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
       }

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

@@ -0,0 +1,177 @@
+/**
+ * @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"
+      },
+      "angularCompilerOptions": {
+        "annotateForClosureCompiler": true
+      },
+      "files": ["test.ts"]
+    }`);
+  });
+
+  // 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));
+  });
+});

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

@@ -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
+ */
+
+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;

modules/@angular/compiler-cli/tsconfig-2015.json

@@ -0,0 +1,34 @@
+{
+    "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"
+    ]
+}

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

@@ -1,11 +1,11 @@
 {
     "compilerOptions": {
-        "module": "commonjs",
-        "target": "es5",
-        "lib": ["es6", "dom"],
-        "noImplicitAny": true,
-        "sourceMap": true,
         "baseUrl": ".",
+        "declaration": true,
+        "experimentalDecorators": true,
+        "noImplicitAny": true,
+        "module": "commonjs",
+        "outDir": "../../../dist/packages-dist/compiler-cli",
         "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": ".",
-        "sourceRoot": ".",
-        "outDir": "../../../dist/packages-dist/compiler-cli",
-        "declaration": true,
+        "sourceMap": true,
+        "inlineSources": true,
+        "target": "es5",
+        "lib": ["es6", "dom"],
         "skipLibCheck": true
     },
     "exclude": ["integrationtest"],

modules/@angular/compiler/index.ts

@@ -21,6 +21,7 @@
  *   </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';
@@ -31,6 +32,7 @@ export * from './src/aot/compiler_host';
 export * from './src/aot/static_reflector';
 export * from './src/aot/static_reflection_capabilities';
 export * from './src/aot/static_symbol';
+export * from './src/aot/summary_resolver';
 export {JitCompiler} from './src/jit/compiler';
 export * from './src/jit/compiler_factory';
 export * from './src/url_resolver';
@@ -58,5 +60,4 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
-
 // This file only reexports content of the `src` folder. Keep it that way.

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

@@ -8,7 +8,7 @@
 
 
 import {isPresent} from '../facade/lang';
-import {Identifiers, resolveIdentifier} from '../identifiers';
+import {Identifiers, createIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ANY_STATE, DEFAULT_STATE, EMPTY_STATE} from '../private_import_core';
 
@@ -69,8 +69,8 @@ class _AnimationBuilder implements AnimationAstVisitor {
       stylesArr.push(o.literalMap(entries));
     });
 
-    return o.importExpr(resolveIdentifier(Identifiers.AnimationStyles)).instantiate([
-      o.importExpr(resolveIdentifier(Identifiers.collectAndResolveStyles)).callFn([
+    return o.importExpr(createIdentifier(Identifiers.AnimationStyles)).instantiate([
+      o.importExpr(createIdentifier(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(resolveIdentifier(Identifiers.AnimationKeyframe)).instantiate([
+    return o.importExpr(createIdentifier(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(resolveIdentifier(Identifiers.balanceAnimationKeyframes)).callFn([
+        o.importExpr(createIdentifier(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(resolveIdentifier(Identifiers.AnimationSequencePlayer)).instantiate([
+    return o.importExpr(createIdentifier(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(resolveIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
+    return o.importExpr(createIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
       o.literalArr(playerExprs)
     ]);
   }
@@ -199,8 +199,9 @@ class _AnimationBuilder implements AnimationAstVisitor {
                         .set(_ANIMATION_FACTORY_VIEW_CONTEXT.callMethod(
                             'getAnimationPlayers',
                             [
-                              _ANIMATION_FACTORY_ELEMENT_VAR, o.literal(this.animationName),
+                              _ANIMATION_FACTORY_ELEMENT_VAR,
                               _ANIMATION_NEXT_STATE_VAR.equals(o.literal(EMPTY_STATE))
+                                  .conditional(o.NULL_EXPR, o.literal(this.animationName))
                             ]))
                         .toDeclStmt());
 
@@ -228,7 +229,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(resolveIdentifier(Identifiers.renderStyles));
+    const RENDER_STYLES_FN = o.importExpr(createIdentifier(Identifiers.renderStyles));
 
     ast.stateTransitions.forEach(transAst => statements.push(transAst.visit(this, context)));
 
@@ -237,7 +238,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     statements.push(new o.IfStmt(
         _ANIMATION_PLAYER_VAR.equals(o.NULL_EXPR),
         [_ANIMATION_PLAYER_VAR
-             .set(o.importExpr(resolveIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
+             .set(o.importExpr(createIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
              .toStmt()]));
 
     // once complete we want to apply the styles on the element
@@ -255,17 +256,18 @@ class _AnimationBuilder implements AnimationAstVisitor {
                                .callFn([
                                  _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
                                  o.importExpr(
-                                      resolveIdentifier(Identifiers.prepareFinalAnimationStyles))
-                                     .callFn([
-                                       _ANIMATION_START_STATE_STYLES_VAR,
-                                       _ANIMATION_END_STATE_STYLES_VAR
-                                     ])
+                                      createIdentifier(Identifiers.prepareFinalAnimationStyles))
+                                     .callFn(
+                                         [
+                                           _ANIMATION_START_STATE_STYLES_VAR,
+                                           _ANIMATION_END_STATE_STYLES_VAR
+                                         ])
                                ])
                                .toStmt()
                          ])])
             .toStmt());
 
-    statements.push(o.importExpr(resolveIdentifier(Identifiers.AnimationSequencePlayer))
+    statements.push(o.importExpr(createIdentifier(Identifiers.AnimationSequencePlayer))
                         .instantiate([_PREVIOUS_ANIMATION_PLAYERS])
                         .callMethod('destroy', [])
                         .toStmt());
@@ -276,7 +278,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     statements.push(RENDER_STYLES_FN
                         .callFn([
                           _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
-                          o.importExpr(resolveIdentifier(Identifiers.clearStyles))
+                          o.importExpr(createIdentifier(Identifiers.clearStyles))
                               .callFn([_ANIMATION_START_STATE_STYLES_VAR])
                         ])
                         .toStmt());
@@ -291,7 +293,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
                         .toStmt());
 
     statements.push(new o.ReturnStatement(
-        o.importExpr(resolveIdentifier(Identifiers.AnimationTransition)).instantiate([
+        o.importExpr(createIdentifier(Identifiers.AnimationTransition)).instantiate([
           _ANIMATION_PLAYER_VAR, _ANIMATION_CURRENT_STATE_VAR, _ANIMATION_NEXT_STATE_VAR,
           _ANIMATION_TIME_VAR
         ])));
@@ -300,12 +302,12 @@ class _AnimationBuilder implements AnimationAstVisitor {
         [
           new o.FnParam(
               _ANIMATION_FACTORY_VIEW_VAR.name,
-              o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+              o.importType(createIdentifier(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(resolveIdentifier(Identifiers.AnimationTransition)));
+        statements, o.importType(createIdentifier(Identifiers.AnimationTransition)));
   }
 
   build(ast: AnimationAst): AnimationEntryCompileResult {

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

@@ -8,7 +8,7 @@
 
 import {Injectable} from '@angular/core';
 
-import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata} from '../compile_metadata';
+import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata, identifierName} from '../compile_metadata';
 import {StringMapWrapper} from '../facade/collection';
 import {isBlank, isPresent} from '../facade/lang';
 import {ParseError} from '../parse_util';
@@ -41,7 +41,7 @@ export class AnimationParser {
 
   parseComponent(component: CompileDirectiveMetadata): AnimationEntryAst[] {
     const errors: string[] = [];
-    const componentName = component.type.name;
+    const componentName = identifierName(component.type);
     const animationTriggerNames = new Set<string>();
     const asts = component.template.animations.map(entry => {
       const result = this.parseEntry(entry);
@@ -174,6 +174,11 @@ 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') {

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

@@ -10,11 +10,11 @@ import {SchemaMetadata} from '@angular/core';
 
 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, createHostComponentMeta} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, CompileTypeSummary, createHostComponentMeta, identifierModuleUrl, identifierName} from '../compile_metadata';
 import {DirectiveNormalizer} from '../directive_normalizer';
 import {DirectiveWrapperCompileResult, DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {ListWrapper} from '../facade/collection';
-import {Identifiers, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
+import {Identifiers, createIdentifier, createIdentifierToken} from '../identifiers';
 import {CompileMetadataResolver} from '../metadata_resolver';
 import {NgModuleCompiler} from '../ng_module_compiler';
 import {OutputEmitter} from '../output/abstract_emitter';
@@ -24,12 +24,11 @@ import {TemplateParser} from '../template_parser/template_parser';
 import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';
 
 import {AotCompilerOptions} from './compiler_options';
+import {GeneratedFile} from './generated_file';
 import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-
-export class SourceModule {
-  constructor(public fileUrl: string, public moduleUrl: string, public source: string) {}
-}
+import {AotSummaryResolver} from './summary_resolver';
+import {filterFileByPatterns} from './utils';
 
 export class AotCompiler {
   private _animationCompiler = new AnimationCompiler();
@@ -39,31 +38,45 @@ export class AotCompiler {
       private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
       private _dirWrapperCompiler: DirectiveWrapperCompiler,
       private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
-      private _localeId: string, private _translationFormat: string,
-      private _animationParser: AnimationParser, private _staticReflector: StaticReflector,
-      private _options: AotCompilerOptions) {}
+      private _summaryResolver: AotSummaryResolver, private _localeId: string,
+      private _translationFormat: string, private _animationParser: AnimationParser,
+      private _staticReflector: StaticReflector, private _options: AotCompilerOptions) {}
 
   clearCache() { this._metadataResolver.clearCache(); }
 
-  compileAll(rootFiles: string[]): Promise<SourceModule[]> {
+  compileAll(rootFiles: string[]): Promise<GeneratedFile[]> {
     const programSymbols = extractProgramSymbols(this._staticReflector, rootFiles, this._options);
     const {ngModuleByPipeOrDirective, files, ngModules} =
         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);
-    });
+    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));
+          return ListWrapper.flatten(sourceModules);
+        });
   }
 
   private _compileSrcFile(
       srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
-      directives: StaticSymbol[], ngModules: StaticSymbol[]): SourceModule[] {
+      directives: StaticSymbol[], pipes: StaticSymbol[],
+      ngModules: StaticSymbol[]): GeneratedFile[] {
     const fileSuffix = _splitTypescriptSuffix(srcFileUrl)[1];
     const statements: o.Statement[] = [];
     const exportedVars: string[] = [];
-    const outputSourceModules: SourceModule[] = [];
+    const generatedFiles: GeneratedFile[] = [];
+
+    // write summary files
+    const summaries: CompileTypeSummary[] = [
+      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
+      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
+      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref))
+    ];
+    generatedFiles.push(this._summaryResolver.serializeSummaries(srcFileUrl, summaries));
 
     // compile all ng modules
     exportedVars.push(
@@ -82,7 +95,7 @@ export class AotCompiler {
       const ngModule = ngModuleByPipeOrDirective.get(dirType);
       if (!ngModule) {
         throw new Error(
-            `Internal Error: cannot determine the module for component ${compMeta.type.name}!`);
+            `Internal Error: cannot determine the module for component ${identifierName(compMeta.type)}!`);
       }
 
       _assertComponent(compMeta);
@@ -90,7 +103,7 @@ export class AotCompiler {
       // compile styles
       const stylesCompileResults = this._styleCompiler.compileComponent(compMeta);
       stylesCompileResults.externalStylesheets.forEach((compiledStyleSheet) => {
-        outputSourceModules.push(this._codgenStyles(srcFileUrl, compiledStyleSheet, fileSuffix));
+        generatedFiles.push(this._codgenStyles(srcFileUrl, compiledStyleSheet, fileSuffix));
       });
 
       // compile components
@@ -103,9 +116,9 @@ export class AotCompiler {
     if (statements.length > 0) {
       const srcModule = this._codegenSourceModule(
           srcFileUrl, _ngfactoryModuleUrl(srcFileUrl), statements, exportedVars);
-      outputSourceModules.unshift(srcModule);
+      generatedFiles.unshift(srcModule);
     }
-    return outputSourceModules;
+    return generatedFiles;
   }
 
   private _compileModule(ngModuleType: StaticSymbol, targetStatements: o.Statement[]): string {
@@ -113,24 +126,24 @@ export class AotCompiler {
     const providers: CompileProviderMetadata[] = [];
 
     if (this._localeId) {
-      providers.push(new CompileProviderMetadata({
-        token: resolveIdentifierToken(Identifiers.LOCALE_ID),
+      providers.push({
+        token: createIdentifierToken(Identifiers.LOCALE_ID),
         useValue: this._localeId,
-      }));
+      });
     }
 
     if (this._translationFormat) {
-      providers.push(new CompileProviderMetadata({
-        token: resolveIdentifierToken(Identifiers.TRANSLATIONS_FORMAT),
+      providers.push({
+        token: createIdentifierToken(Identifiers.TRANSLATIONS_FORMAT),
         useValue: this._translationFormat
-      }));
+      });
     }
 
     const appCompileResult = this._ngModuleCompiler.compile(ngModule, providers);
 
     appCompileResult.dependencies.forEach((dep) => {
-      dep.placeholder.name = _componentFactoryName(dep.comp);
-      dep.placeholder.moduleUrl = _ngfactoryModuleUrl(dep.comp.moduleUrl);
+      dep.placeholder.reference = this._staticReflector.getStaticSymbol(
+          _ngfactoryModuleUrl(identifierModuleUrl(dep.comp)), _componentFactoryName(dep.comp));
     });
 
     targetStatements.push(...appCompileResult.statements);
@@ -149,14 +162,17 @@ export class AotCompiler {
   private _compileComponentFactory(
       compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata, fileSuffix: string,
       targetStatements: o.Statement[]): string {
-    const hostMeta = createHostComponentMeta(compMeta);
+    const hostMeta = createHostComponentMeta(
+        this._staticReflector.getStaticSymbol(
+            identifierModuleUrl(compMeta.type), `${identifierName(compMeta.type)}_Host`),
+        compMeta);
     const hostViewFactoryVar = this._compileComponent(
         hostMeta, ngModule, [compMeta.type], null, fileSuffix, targetStatements);
     const compFactoryVar = _componentFactoryName(compMeta.type);
     targetStatements.push(
         o.variable(compFactoryVar)
-            .set(o.importExpr(resolveIdentifier(Identifiers.ComponentFactory), [o.importType(
-                                                                                   compMeta.type)])
+            .set(o.importExpr(
+                      createIdentifier(Identifiers.ComponentFactory), [o.importType(compMeta.type)])
                      .instantiate(
                          [
                            o.literal(compMeta.selector),
@@ -164,7 +180,7 @@ export class AotCompiler {
                            o.importExpr(compMeta.type),
                          ],
                          o.importType(
-                             resolveIdentifier(Identifiers.ComponentFactory),
+                             createIdentifier(Identifiers.ComponentFactory),
                              [o.importType(compMeta.type)], [o.TypeModifier.Const])))
             .toDeclStmt(null, [o.StmtModifier.Final]));
     return compFactoryVar;
@@ -182,23 +198,24 @@ export class AotCompiler {
 
     const parsedTemplate = this._templateParser.parse(
         compMeta, compMeta.template.template, directives, pipes, ngModule.schemas,
-        compMeta.type.name);
+        identifierName(compMeta.type));
     const stylesExpr = componentStyles ? o.variable(componentStyles.stylesVar) : o.literalArr([]);
     const compiledAnimations =
-        this._animationCompiler.compile(compMeta.type.name, parsedAnimations);
+        this._animationCompiler.compile(identifierName(compMeta.type), parsedAnimations);
     const viewResult = this._viewCompiler.compileComponent(
         compMeta, parsedTemplate, stylesExpr, pipes, compiledAnimations);
     if (componentStyles) {
-      targetStatements.push(..._resolveStyleStatements(componentStyles, fileSuffix));
+      targetStatements.push(
+          ..._resolveStyleStatements(this._staticReflector, componentStyles, fileSuffix));
     }
     compiledAnimations.forEach(entry => targetStatements.push(...entry.statements));
-    targetStatements.push(..._resolveViewStatements(viewResult));
+    targetStatements.push(..._resolveViewStatements(this._staticReflector, viewResult));
     return viewResult.viewClassVar;
   }
 
   private _codgenStyles(
-      fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): SourceModule {
-    _resolveStyleStatements(stylesCompileResult, fileSuffix);
+      fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): GeneratedFile {
+    _resolveStyleStatements(this._staticReflector, stylesCompileResult, fileSuffix);
     return this._codegenSourceModule(
         fileUrl, _stylesModuleUrl(
                      stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
@@ -206,26 +223,29 @@ export class AotCompiler {
   }
 
   private _codegenSourceModule(
-      fileUrl: string, moduleUrl: string, statements: o.Statement[],
-      exportedVars: string[]): SourceModule {
-    return new SourceModule(
-        fileUrl, moduleUrl,
-        this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
+      srcFileUrl: string, genFileUrl: string, statements: o.Statement[],
+      exportedVars: string[]): GeneratedFile {
+    return new GeneratedFile(
+        srcFileUrl, genFileUrl,
+        this._outputEmitter.emitStatements(genFileUrl, statements, exportedVars));
   }
 }
 
-function _resolveViewStatements(compileResult: ViewCompileResult): o.Statement[] {
+function _resolveViewStatements(
+    reflector: StaticReflector, compileResult: ViewCompileResult): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
     if (dep instanceof ViewClassDependency) {
       const vfd = <ViewClassDependency>dep;
-      vfd.placeholder.moduleUrl = _ngfactoryModuleUrl(vfd.comp.moduleUrl);
+      vfd.placeholder.reference =
+          reflector.getStaticSymbol(_ngfactoryModuleUrl(identifierModuleUrl(vfd.comp)), dep.name);
     } else if (dep instanceof ComponentFactoryDependency) {
       const cfd = <ComponentFactoryDependency>dep;
-      cfd.placeholder.name = _componentFactoryName(cfd.comp);
-      cfd.placeholder.moduleUrl = _ngfactoryModuleUrl(cfd.comp.moduleUrl);
+      cfd.placeholder.reference = reflector.getStaticSymbol(
+          _ngfactoryModuleUrl(identifierModuleUrl(cfd.comp)), _componentFactoryName(cfd.comp));
     } else if (dep instanceof DirectiveWrapperDependency) {
       const dwd = <DirectiveWrapperDependency>dep;
-      dwd.placeholder.moduleUrl = _ngfactoryModuleUrl(dwd.dir.moduleUrl);
+      dwd.placeholder.reference =
+          reflector.getStaticSymbol(_ngfactoryModuleUrl(identifierModuleUrl(dwd.dir)), dwd.name);
     }
   });
   return compileResult.statements;
@@ -233,9 +253,11 @@ function _resolveViewStatements(compileResult: ViewCompileResult): o.Statement[]
 
 
 function _resolveStyleStatements(
-    compileResult: CompiledStylesheet, fileSuffix: string): o.Statement[] {
+    reflector: StaticReflector, compileResult: CompiledStylesheet,
+    fileSuffix: string): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
-    dep.valuePlaceholder.moduleUrl = _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, fileSuffix);
+    dep.valuePlaceholder.reference = reflector.getStaticSymbol(
+        _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, fileSuffix), dep.name);
   });
   return compileResult.statements;
 }
@@ -246,16 +268,17 @@ function _ngfactoryModuleUrl(dirUrl: string): string {
 }
 
 function _componentFactoryName(comp: CompileIdentifierMetadata): string {
-  return `${comp.name}NgFactory`;
+  return `${identifierName(comp)}NgFactory`;
 }
 
 function _stylesModuleUrl(stylesheetUrl: string, shim: boolean, suffix: string): string {
-  return shim ? `${stylesheetUrl}.shim${suffix}` : `${stylesheetUrl}${suffix}`;
+  return `${stylesheetUrl}${shim ? '.shim' : ''}.ngstyle${suffix}`;
 }
 
 function _assertComponent(meta: CompileDirectiveMetadata) {
   if (!meta.isComponent) {
-    throw new Error(`Could not compile '${meta.type.name}' because it is not a component.`);
+    throw new Error(
+        `Could not compile '${identifierName(meta.type)}' because it is not a component.`);
   }
 }
 
@@ -276,7 +299,12 @@ function _splitTypescriptSuffix(path: string): string[] {
 export interface NgAnalyzedModules {
   ngModules: CompileNgModuleMetadata[];
   ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>;
-  files: Array<{srcUrl: string, directives: StaticSymbol[], ngModules: StaticSymbol[]}>;
+  files: Array<{
+    srcUrl: string,
+    directives: StaticSymbol[],
+    pipes: StaticSymbol[],
+    ngModules: StaticSymbol[]
+  }>;
   symbolsMissingModule?: StaticSymbol[];
 }
 
@@ -303,14 +331,6 @@ 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(
     ngModuleMetas: CompileNgModuleMetadata[],
     symbolsMissingModule: StaticSymbol[]): NgAnalyzedModules {
@@ -319,11 +339,13 @@ function _analyzeNgModules(
   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 filePaths = new Set<string>();
 
   // 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;
@@ -341,16 +363,23 @@ 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[], ngModules: StaticSymbol[]}[] = [];
+  const files:
+      {srcUrl: string,
+       directives: StaticSymbol[],
+       pipes: StaticSymbol[],
+       ngModules: StaticSymbol[]}[] = [];
 
   filePaths.forEach((srcUrl) => {
     const directives = ngDirectivesByFile.get(srcUrl) || [];
+    const pipes = ngPipesByFile.get(srcUrl) || [];
     const ngModules = ngModulesByFile.get(srcUrl) || [];
-    files.push({srcUrl, directives, ngModules});
+    files.push({srcUrl, directives, pipes, ngModules});
   });
 
   return {
@@ -366,10 +395,10 @@ export function extractProgramSymbols(
     staticReflector: StaticReflector, files: string[],
     options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}): StaticSymbol[] {
   const staticSymbols: StaticSymbol[] = [];
-  files.filter(fileName => _filterFileByPatterns(fileName, options)).forEach(sourceFile => {
+  files.filter(fileName => filterFileByPatterns(fileName, options)).forEach(sourceFile => {
     const moduleMetadata = staticReflector.getModuleMetadata(sourceFile);
     if (!moduleMetadata) {
-      console.log(`WARNING: no metadata found for ${sourceFile}`);
+      console.error(`WARNING: no metadata found for ${sourceFile}`);
       return;
     }
 
@@ -404,16 +433,16 @@ function _createNgModules(
   const ngModulePipesAndDirective = new Set<StaticSymbol>();
 
   const addNgModule = (staticSymbol: any) => {
-    if (ngModules.has(staticSymbol) || !_filterFileByPatterns(staticSymbol.filePath, options)) {
+    if (ngModules.has(staticSymbol) || !filterFileByPatterns(staticSymbol.filePath, options)) {
       return false;
     }
-    const ngModule = metadataResolver.getUnloadedNgModuleMetadata(staticSymbol, false, false);
+    const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, 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.type.reference));
+      ngModule.transitiveModule.modules.forEach(modMeta => addNgModule(modMeta.reference));
     }
     return !!ngModule;
   };
@@ -430,15 +459,3 @@ 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;
-}

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

@@ -34,8 +34,7 @@ import {AotCompilerHost} from './compiler_host';
 import {AotCompilerOptions} from './compiler_options';
 import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
 import {StaticReflector} from './static_reflector';
-
-
+import {AotSummaryResolver} from './summary_resolver';
 
 /**
  * Creates a new AotCompiler based on options and a host.
@@ -61,15 +60,17 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
   const console = new Console();
   const tmplParser =
       new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
+  const summaryResolver = new AotSummaryResolver(compilerHost, staticReflector, options);
   const resolver = new CompileMetadataResolver(
       new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-      new PipeResolver(staticReflector), elementSchemaRegistry, normalizer, staticReflector);
+      new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
+      staticReflector);
   // TODO(vicb): do not pass options.i18nFormat here
   const compiler = new AotCompiler(
       resolver, tmplParser, new StyleCompiler(urlResolver),
       new ViewCompiler(config, elementSchemaRegistry),
       new DirectiveWrapperCompiler(config, expressionParser, elementSchemaRegistry, console),
-      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), options.locale,
+      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), summaryResolver, options.locale,
       options.i18nFormat, new AnimationParser(elementSchemaRegistry), staticReflector, options);
   return {compiler, reflector: staticReflector};
 }

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

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

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

@@ -6,8 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-/**
- * @module
- * @description
- * This module provides a set of common Pipes.
- */
+export class GeneratedFile {
+  constructor(public srcFileUrl: string, public genFileUrl: string, public source: string) {}
+}

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

@@ -10,7 +10,7 @@ import {Attribute, Component, ContentChild, ContentChildren, Directive, Host, Ho
 import {ReflectorReader} from '../private_import_core';
 import {StaticSymbol} from './static_symbol';
 
-const SUPPORTED_SCHEMA_VERSION = 2;
+const SUPPORTED_SCHEMA_VERSION = 3;
 const ANGULAR_IMPORT_LOCATIONS = {
   coreDecorators: '@angular/core/src/metadata',
   diDecorators: '@angular/core/src/di/metadata',
@@ -20,6 +20,8 @@ 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.
@@ -70,16 +72,25 @@ export class StaticSymbolCache {
 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 host: StaticReflectorHost,
-      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache()) {
+      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache(),
+      knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
+      knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
+      private errorRecorder?: (error: any, fileName: string) => void) {
     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 {
@@ -99,29 +110,45 @@ 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']) {
-        annotations = this.simplify(type, classMetadata['decorators']);
-      } else {
-        annotations = [];
+        const ownAnnotations: any[] = this.simplify(type, classMetadata['decorators']);
+        annotations.push(...ownAnnotations);
       }
       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);
-      const members = classMetadata ? classMetadata['members'] : {};
-      propMetadata = mapStringMap(members, (propData, propName) => {
+      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 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']) {
-          return this.simplify(type, prop['decorators']);
-        } else {
-          return [];
+          decorators.push(...this.simplify(type, prop['decorators']));
         }
       });
       this.propertyCache.set(type, propMetadata);
@@ -131,7 +158,10 @@ export class StaticReflector implements ReflectorReader {
 
   public parameters(type: StaticSymbol): any[] {
     if (!(type instanceof StaticSymbol)) {
-      throw new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`);
+      this.reportError(
+          new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`),
+          type);
+      return [];
     }
     try {
       let parameters = this.parameterCache.get(type);
@@ -155,6 +185,8 @@ export class StaticReflector implements ReflectorReader {
             }
             parameters.push(nestedResult);
           });
+        } else if (classMetadata['extends']) {
+          parameters = this.parameters(this.simplify(type, classMetadata['extends']));
         }
         if (!parameters) {
           parameters = [];
@@ -163,28 +195,54 @@ export class StaticReflector implements ReflectorReader {
       }
       return parameters;
     } catch (e) {
-      console.log(`Failed on type ${JSON.stringify(type)} with error ${e}`);
+      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
       throw e;
     }
   }
 
-  hasLifecycleHook(type: any, lcProperty: string): boolean {
-    if (!(type instanceof StaticSymbol)) {
-      throw new Error(
-          `hasLifecycleHook received ${JSON.stringify(type)} which is not a StaticSymbol`);
+  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);
     }
-    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;
+    return methodNames;
   }
 
-  private registerDecoratorOrConstructor(type: StaticSymbol, ctor: any): void {
+  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;
+    }
+  }
+
+  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));
   }
 
@@ -193,50 +251,51 @@ 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);
   }
 
   /**
@@ -250,11 +309,21 @@ export class StaticReflector implements ReflectorReader {
     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}`);
+        this.reportError(
+            new Error(`Could not resolve module '${moduleName}' relative to file ${filePath}`),
+            null, filePath);
       }
       return resolvedModulePath;
     };
@@ -287,7 +356,12 @@ export class StaticReflector implements ReflectorReader {
               if (typeof exportSymbol !== 'string') {
                 symName = exportSymbol.name;
               }
-              staticSymbol = this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+              const resolvedModule = resolveModule(moduleExport.from);
+              if (resolvedModule) {
+                staticSymbol =
+                    this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+                break;
+              }
             }
           }
         }
@@ -297,10 +371,12 @@ export class StaticReflector implements ReflectorReader {
           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;
+              if (resolvedModule) {
+                const candidateSymbol = this.resolveExportedSymbol(resolvedModule, symbolName);
+                if (candidateSymbol) {
+                  staticSymbol = candidateSymbol;
+                  break;
+                }
               }
             }
           }
@@ -333,7 +409,7 @@ export class StaticReflector implements ReflectorReader {
 
   /** @internal */
   public simplify(context: StaticSymbol, value: any): any {
-    const _this = this;
+    const self = this;
     let scope = BindingScope.empty;
     const calling = new Map<StaticSymbol, boolean>();
 
@@ -342,15 +418,15 @@ export class StaticReflector implements ReflectorReader {
         let staticSymbol: StaticSymbol;
         if (expression['module']) {
           staticSymbol =
-              _this.findDeclaration(expression['module'], expression['name'], context.filePath);
+              self.findDeclaration(expression['module'], expression['name'], context.filePath);
         } else {
-          staticSymbol = _this.getStaticSymbol(context.filePath, expression['name']);
+          staticSymbol = self.getStaticSymbol(context.filePath, expression['name']);
         }
         return staticSymbol;
       }
 
       function resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        const moduleMetadata = _this.getModuleMetadata(staticSymbol.filePath);
+        const moduleMetadata = self.getModuleMetadata(staticSymbol.filePath);
         const declarationValue =
             moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
         return declarationValue;
@@ -360,7 +436,7 @@ export class StaticReflector implements ReflectorReader {
         if (value && value.__symbolic === 'new' && value.expression) {
           const target = value.expression;
           if (target.__symbolic == 'reference') {
-            return sameSymbol(resolveReference(context, target), _this.opaqueToken);
+            return sameSymbol(resolveReference(context, target), self.opaqueToken);
           }
         }
         return false;
@@ -542,24 +618,31 @@ export class StaticReflector implements ReflectorReader {
                 if (indexTarget && isPrimitive(index)) return indexTarget[index];
                 return null;
               case 'select':
+                let selectContext = context;
                 let selectTarget = simplify(expression['expression']);
                 if (selectTarget instanceof StaticSymbol) {
                   // Access to a static instance variable
+                  const member: string = expression['member'];
+                  const members = selectTarget.members ?
+                      (selectTarget.members as string[]).concat(member) :
+                      [member];
                   const declarationValue = resolveReferenceValue(selectTarget);
+                  selectContext =
+                      self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
                   if (declarationValue && declarationValue.statics) {
                     selectTarget = declarationValue.statics;
                   } else {
-                    const member: string = expression['member'];
-                    const members = selectTarget.members ?
-                        (selectTarget.members as string[]).concat(member) :
-                        [member];
-                    return _this.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
+                    return selectContext;
                   }
                 }
-                const member = simplify(expression['member']);
-                if (selectTarget && isPrimitive(member)) return simplify(selectTarget[member]);
+                const member = simplifyInContext(selectContext, expression['member'], depth + 1);
+                if (selectTarget && isPrimitive(member))
+                  return simplifyInContext(selectContext, selectTarget[member], depth + 1);
                 return null;
               case 'reference':
+                if (!expression['name']) {
+                  return context;
+                }
                 if (!expression.module) {
                   const name: string = expression['name'];
                   const localValue = scope.resolve(name);
@@ -589,11 +672,11 @@ export class StaticReflector implements ReflectorReader {
                 let target = expression['expression'];
                 if (target['module']) {
                   staticSymbol =
-                      _this.findDeclaration(target['module'], target['name'], context.filePath);
+                      self.findDeclaration(target['module'], target['name'], context.filePath);
                 } else {
-                  staticSymbol = _this.getStaticSymbol(context.filePath, target['name']);
+                  staticSymbol = self.getStaticSymbol(context.filePath, target['name']);
                 }
-                let converter = _this.conversionMap.get(staticSymbol);
+                let converter = self.conversionMap.get(staticSymbol);
                 if (converter) {
                   let args: any[] = expression['arguments'];
                   if (!args) {
@@ -634,7 +717,16 @@ export class StaticReflector implements ReflectorReader {
       }
     }
 
-    const result = simplifyInContext(context, value, 0);
+    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);
     if (shouldIgnore(result)) {
       return undefined;
     }
@@ -662,8 +754,10 @@ export class StaticReflector implements ReflectorReader {
             {__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}`);
+        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);
     }
@@ -717,7 +811,11 @@ function mapStringMap(input: {[key: string]: any}, transform: (value: any, key:
   Object.keys(input).forEach((key) => {
     const value = transform(input[key], key);
     if (!shouldIgnore(value)) {
-      result[key] = value;
+      if (HIDDEN_KEY.test(key)) {
+        Object.defineProperty(result, key, {enumerable: false, configurable: true, value: value});
+      } else {
+        result[key] = value;
+      }
     }
   });
   return result;

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

@@ -6,10 +6,6 @@
  * 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.
  *

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function filterFileByPatterns(
+    fileName: string, options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}) {
+  let match = true;
+  if (options.includeFilePattern) {
+    match = match && !!options.includeFilePattern.exec(fileName);
+  }
+  if (options.excludeFilePattern) {
+    match = match && !options.excludeFilePattern.exec(fileName);
+  }
+  return match;
+}

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

@@ -8,11 +8,12 @@
 
 import {ChangeDetectionStrategy, SchemaMetadata, Type, ViewEncapsulation} from '@angular/core';
 
+import {StaticSymbol} from './aot/static_symbol';
 import {ListWrapper} from './facade/collection';
-import {isPresent} from './facade/lang';
-import {LifecycleHooks} from './private_import_core';
+import {isPresent, stringify} from './facade/lang';
+import {LifecycleHooks, reflector} from './private_import_core';
 import {CssSelector} from './selector';
-import {sanitizeIdentifier, splitAtColon} from './util';
+import {splitAtColon} from './util';
 
 function unimplemented(): any {
   throw new Error('unimplemented');
@@ -24,10 +25,6 @@ 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) {}
@@ -78,24 +75,50 @@ 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;
 
-  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;
+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;
   }
+  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;
+}
 
-  get identifier(): CompileIdentifierMetadata { return this; }
+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 {
+  Template,
+  Pipe,
+  Directive,
+  NgModule
 }
 
 /**
@@ -103,158 +126,69 @@ export class CompileIdentifierMetadata implements CompileMetadataWithIdentifier
  * in other modules / components. However, this data is not enough to compile
  * the directive / module itself.
  */
-export interface CompileSummary {
-  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+export interface CompileSummary { summaryKind: CompileSummaryKind; }
+
+export interface CompileTypeSummary extends CompileSummary { type: CompileTypeMetadata; }
+
+export interface CompileDiDependencyMetadata {
+  isAttribute?: boolean;
+  isSelf?: boolean;
+  isHost?: boolean;
+  isSkipSelf?: boolean;
+  isOptional?: boolean;
+  isValue?: boolean;
+  token?: CompileTokenMetadata;
+  value?: any;
 }
 
-export class CompileDiDependencyMetadata {
-  isAttribute: boolean;
-  isSelf: boolean;
-  isHost: boolean;
-  isSkipSelf: boolean;
-  isOptional: boolean;
-  isValue: boolean;
+export interface CompileProviderMetadata {
   token: CompileTokenMetadata;
-  value: any;
-
-  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;
-  }
+  useClass?: CompileTypeMetadata;
+  useValue?: any;
+  useExisting?: CompileTokenMetadata;
+  useFactory?: CompileFactoryMetadata;
+  deps?: CompileDiDependencyMetadata[];
+  multi?: boolean;
 }
 
-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 {
+export interface CompileFactoryMetadata extends CompileIdentifierMetadata {
   diDeps: CompileDiDependencyMetadata[];
+  reference: any;
+}
 
-  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 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;
   }
 }
 
-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;
-  }
+export interface CompileTokenMetadata {
+  value?: any;
+  identifier?: CompileIdentifierMetadata|CompileTypeMetadata;
 }
 
 /**
  * Metadata regarding compilation of a type.
  */
-export class CompileTypeMetadata extends CompileIdentifierMetadata {
-  isHost: boolean;
+export interface CompileTypeMetadata extends CompileIdentifierMetadata {
   diDeps: CompileDiDependencyMetadata[];
   lifecycleHooks: LifecycleHooks[];
-
-  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);
-  }
+  reference: any;
 }
 
-export class CompileQueryMetadata {
+export interface 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;
-  }
 }
 
 /**
@@ -277,7 +211,6 @@ export class CompileStylesheetMetadata {
  * Summary Metadata regarding compilation of a template.
  */
 export interface CompileTemplateSummary extends CompileSummary {
-  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
   animations: string[];
   ngContentSelectors: string[];
   encapsulation: ViewEncapsulation;
@@ -325,7 +258,7 @@ export class CompileTemplateMetadata {
 
   toSummary(): CompileTemplateSummary {
     return {
-      isSummary: true,
+      summaryKind: CompileSummaryKind.Template,
       animations: this.animations.map(anim => anim.name),
       ngContentSelectors: this.ngContentSelectors,
       encapsulation: this.encapsulation
@@ -333,8 +266,9 @@ export class CompileTemplateMetadata {
   }
 }
 
-export interface CompileDirectiveSummary extends CompileSummary {
-  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+// 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 {
   type: CompileTypeMetadata;
   isComponent: boolean;
   selector: string;
@@ -355,10 +289,11 @@ export interface CompileDirectiveSummary extends CompileSummary {
 /**
  * Metadata regarding compilation of a directive.
  */
-export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
+export class CompileDirectiveMetadata {
   static create(
-      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host, providers,
-       viewProviders, queries, viewQueries, entryComponents, template}: {
+      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host,
+       providers, viewProviders, queries, viewQueries, entryComponents, template}: {
+        isHost?: boolean,
         type?: CompileTypeMetadata,
         isComponent?: boolean,
         selector?: string,
@@ -367,10 +302,8 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
         inputs?: string[],
         outputs?: string[],
         host?: {[key: string]: string},
-        providers?:
-            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
-        viewProviders?:
-            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        providers?: CompileProviderMetadata[],
+        viewProviders?: CompileProviderMetadata[],
         queries?: CompileQueryMetadata[],
         viewQueries?: CompileQueryMetadata[],
         entryComponents?: CompileIdentifierMetadata[],
@@ -412,6 +345,7 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
     }
 
     return new CompileDirectiveMetadata({
+      isHost,
       type,
       isComponent: !!isComponent, selector, exportAs, changeDetection,
       inputs: inputsMap,
@@ -427,6 +361,7 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
       template,
     });
   }
+  isHost: boolean;
   type: CompileTypeMetadata;
   isComponent: boolean;
   selector: string;
@@ -446,9 +381,10 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
   template: CompileTemplateMetadata;
 
   constructor(
-      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, hostListeners,
-       hostProperties, hostAttributes, providers, viewProviders, queries, viewQueries,
-       entryComponents, template}: {
+      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
+       hostListeners, hostProperties, hostAttributes, providers, viewProviders, queries,
+       viewQueries, entryComponents, template}: {
+        isHost?: boolean,
         type?: CompileTypeMetadata,
         isComponent?: boolean,
         selector?: string,
@@ -459,15 +395,14 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
         hostListeners?: {[key: string]: string},
         hostProperties?: {[key: string]: string},
         hostAttributes?: {[key: string]: string},
-        providers?:
-            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
-        viewProviders?:
-            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        providers?: CompileProviderMetadata[],
+        viewProviders?: CompileProviderMetadata[],
         queries?: CompileQueryMetadata[],
         viewQueries?: CompileQueryMetadata[],
         entryComponents?: CompileIdentifierMetadata[],
         template?: CompileTemplateMetadata,
       } = {}) {
+    this.isHost = !!isHost;
     this.type = type;
     this.isComponent = isComponent;
     this.selector = selector;
@@ -487,11 +422,9 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
     this.template = template;
   }
 
-  get identifier(): CompileIdentifierMetadata { return this.type; }
-
   toSummary(): CompileDirectiveSummary {
     return {
-      isSummary: true,
+      summaryKind: CompileSummaryKind.Directive,
       type: this.type,
       isComponent: this.isComponent,
       selector: this.selector,
@@ -514,16 +447,12 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
 /**
  * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
  */
-export function createHostComponentMeta(compMeta: CompileDirectiveMetadata):
-    CompileDirectiveMetadata {
+export function createHostComponentMeta(
+    typeReference: any, compMeta: CompileDirectiveMetadata): CompileDirectiveMetadata {
   const template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate();
   return CompileDirectiveMetadata.create({
-    type: new CompileTypeMetadata({
-      reference: Object,
-      name: `${compMeta.type.name}_Host`,
-      moduleUrl: compMeta.type.moduleUrl,
-      isHost: true
-    }),
+    isHost: true,
+    type: {reference: typeReference, diDeps: [], lifecycleHooks: []},
     template: new CompileTemplateMetadata({
       encapsulation: ViewEncapsulation.None,
       template: template,
@@ -546,14 +475,13 @@ export function createHostComponentMeta(compMeta: CompileDirectiveMetadata):
   });
 }
 
-export interface CompilePipeSummary extends CompileSummary {
-  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+export interface CompilePipeSummary extends CompileTypeSummary {
   type: CompileTypeMetadata;
   name: string;
   pure: boolean;
 }
 
-export class CompilePipeMetadata implements CompileMetadataWithIdentifier {
+export class CompilePipeMetadata {
   type: CompileTypeMetadata;
   name: string;
   pure: boolean;
@@ -567,42 +495,44 @@ export class CompilePipeMetadata implements CompileMetadataWithIdentifier {
     this.name = name;
     this.pure = !!pure;
   }
-  get identifier(): CompileIdentifierMetadata { return this.type; }
 
   toSummary(): CompilePipeSummary {
-    return {isSummary: true, type: this.type, name: this.name, pure: this.pure};
+    return {
+      summaryKind: CompileSummaryKind.Pipe,
+      type: this.type,
+      name: this.name,
+      pure: this.pure
+    };
   }
 }
 
-export interface CompileNgModuleInjectorSummary extends CompileSummary {
-  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+// 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 {
   type: CompileTypeMetadata;
-  entryComponents: CompileIdentifierMetadata[];
-  providers: CompileProviderMetadata[];
-  importedModules: CompileNgModuleInjectorSummary[];
-  exportedModules: CompileNgModuleInjectorSummary[];
-}
 
-export interface CompileNgModuleDirectiveSummary 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[];
-  exportedModules: CompileNgModuleDirectiveSummary[];
-  directiveLoaders: (() => Promise<void>)[];
-}
 
-export type CompileNgModuleSummary =
-    CompileNgModuleInjectorSummary & CompileNgModuleDirectiveSummary;
+  // Note: This is transitive.
+  entryComponents: CompileIdentifierMetadata[];
+  // Note: This is transitive.
+  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[];
+  // Note: This is transitive.
+  modules: CompileTypeMetadata[];
+}
 
 /**
  * Metadata regarding compilation of a module.
  */
-export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
+export class CompileNgModuleMetadata {
   type: CompileTypeMetadata;
   declaredDirectives: CompileIdentifierMetadata[];
   exportedDirectives: CompileIdentifierMetadata[];
   declaredPipes: CompileIdentifierMetadata[];
+
   exportedPipes: CompileIdentifierMetadata[];
   entryComponents: CompileIdentifierMetadata[];
   bootstrapComponents: CompileIdentifierMetadata[];
@@ -620,8 +550,7 @@ export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
        entryComponents, bootstrapComponents, importedModules, exportedModules, schemas,
        transitiveModule, id}: {
         type?: CompileTypeMetadata,
-        providers?:
-            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        providers?: CompileProviderMetadata[],
         declaredDirectives?: CompileIdentifierMetadata[],
         exportedDirectives?: CompileIdentifierMetadata[],
         declaredPipes?: CompileIdentifierMetadata[],
@@ -649,69 +578,75 @@ export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
     this.transitiveModule = transitiveModule;
   }
 
-  get identifier(): CompileIdentifierMetadata { return this.type; }
-
   toSummary(): CompileNgModuleSummary {
     return {
-      isSummary: true,
+      summaryKind: CompileSummaryKind.NgModule,
       type: this.type,
-      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
+      entryComponents: this.transitiveModule.entryComponents,
+      providers: this.transitiveModule.providers,
+      modules: this.transitiveModule.modules,
+      exportedDirectives: this.transitiveModule.exportedDirectives,
+      exportedPipes: this.transitiveModule.exportedPipes
     };
   }
 }
 
 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[] = [];
 
-  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));
+  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[] = [];
+
+  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>();
-
-  items.forEach((item) => {
-    if (!map.get(item.identifier.reference)) {
-      map.set(item.identifier.reference, item);
+  addDirective(id: CompileIdentifierMetadata) {
+    if (!this.directivesSet.has(id.reference)) {
+      this.directivesSet.add(id.reference);
+      this.directives.push(id);
     }
-  });
-
-  return Array.from(map.values());
+  }
+  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);
+    }
+  }
 }
 
 function _normalizeArray(obj: any[]): any[] {

modules/@angular/compiler/src/compiler_util/binding_util.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Identifiers, resolveIdentifier} from '../identifiers';
+import {Identifiers, createIdentifier} 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(resolveIdentifier(Identifiers.UNINITIALIZED)))
+                             .set(o.importExpr(createIdentifier(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(resolveIdentifier(Identifiers.checkBinding)).callFn([
+  let condition: o.Expression = o.importExpr(createIdentifier(Identifiers.checkBinding)).callFn([
     throwOnChangeVar, fieldExpr, evalResult.currValExpr
   ]);
   if (evalResult.forceUpdate) {

modules/@angular/compiler/src/compiler_util/expression_converter.ts

@@ -9,7 +9,7 @@
 
 import * as cdAst from '../expression_parser/ast';
 import {isBlank, isPresent} from '../facade/lang';
-import {Identifiers, resolveIdentifier} from '../identifiers';
+import {Identifiers, createIdentifier} 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(resolveIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
+            .set(o.importExpr(createIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
             .toDeclStmt(null, [o.StmtModifier.Final]));
   }
   return unwrapperStmts;
@@ -277,15 +277,20 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     args.push(o.literal(ast.strings[ast.strings.length - 1]));
 
     return ast.expressions.length <= 9 ?
-        o.importExpr(resolveIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
-        o.importExpr(resolveIdentifier(Identifiers.interpolate)).callFn([
+        o.importExpr(createIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
+        o.importExpr(createIdentifier(Identifiers.interpolate)).callFn([
           args[0], o.literalArr(args.slice(1))
         ]);
   }
 
   visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {
-    return convertToStatementIfNeeded(
-        mode, this.visit(ast.obj, _Mode.Expression).key(this.visit(ast.key, _Mode.Expression)));
+    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)));
+    }
   }
 
   visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {
@@ -578,7 +583,7 @@ function flattenStatements(arg: any, output: o.Statement[]) {
 
 function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[]): o.Expression {
   if (values.length === 0) {
-    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_ARRAY));
+    return o.importExpr(createIdentifier(Identifiers.EMPTY_ARRAY));
   }
   const proxyExpr = o.THIS_EXPR.prop(`_arr_${builder.fields.length}`);
   const proxyParams: o.FnParam[] = [];
@@ -599,7 +604,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(resolveIdentifier(Identifiers.EMPTY_MAP));
+    return o.importExpr(createIdentifier(Identifiers.EMPTY_MAP));
   }
   const proxyExpr = o.THIS_EXPR.prop(`_map_${builder.fields.length}`);
   const proxyParams: o.FnParam[] = [];

modules/@angular/compiler/src/compiler_util/identifier_util.ts

@@ -8,15 +8,12 @@
 
 import {CompileTokenMetadata} from '../compile_metadata';
 import {isPresent} from '../facade/lang';
-import {IdentifierSpec, Identifiers, resolveEnumIdentifier, resolveIdentifier} from '../identifiers';
+import {IdentifierSpec, Identifiers, createEnumIdentifier, createIdentifier} 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);
   }
@@ -24,13 +21,13 @@ export function createDiTokenExpression(token: CompileTokenMetadata): o.Expressi
 
 export function createInlineArray(values: o.Expression[]): o.Expression {
   if (values.length === 0) {
-    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
+    return o.importExpr(createIdentifier(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 = resolveIdentifier(identifierSpec);
+  const identifier = createIdentifier(identifierSpec);
   return o.importExpr(identifier).instantiate([
     <o.Expression>o.literal(values.length)
   ].concat(values));
@@ -46,7 +43,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(resolveIdentifier(pureProxyId)).callFn([fn]))
+                             .set(o.importExpr(createIdentifier(pureProxyId)).callFn([fn]))
                              .toStmt());
 }
 
@@ -56,5 +53,5 @@ export function createEnumExpression(enumType: IdentifierSpec, enumValue: any):
   if (!enumName) {
     throw new Error(`Unknown enum value ${enumValue} in ${enumType.name}`);
   }
-  return o.importExpr(resolveEnumIdentifier(resolveIdentifier(enumType), enumName));
+  return o.importExpr(createEnumIdentifier(enumType, enumName));
 }

modules/@angular/compiler/src/compiler_util/render_util.ts

@@ -8,7 +8,7 @@
 import {SecurityContext} from '@angular/core';
 
 import {isPresent} from '../facade/lang';
-import {Identifiers, resolveIdentifier} from '../identifiers';
+import {Identifiers, createIdentifier} 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(resolveIdentifier(Identifiers.setBindingDebugInfo))
+            o.importExpr(createIdentifier(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,
-    eventListener: o.Expression, renderElement: o.Expression, renderValue: o.Expression,
-    lastRenderValue: o.Expression) {
+    boundOutputs: BoundEventAst[], 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(resolveIdentifier(Identifiers.UNINITIALIZED));
+  const unitializedValue = o.importExpr(createIdentifier(Identifiers.UNINITIALIZED));
   const animationTransitionVar = o.variable('animationTransition_' + animationName);
 
   updateStmts.push(
@@ -121,23 +121,32 @@ export function triggerAnimation(
           .set(animationFnExpr.callFn([view, renderElement, lastRenderValue, emptyStateValue]))
           .toDeclStmt());
 
-  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 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 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);

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

@@ -9,7 +9,7 @@
 import {ViewEncapsulation, isDevMode} from '@angular/core';
 
 import {CompileIdentifierMetadata} from './compile_metadata';
-import {Identifiers, resolveIdentifier} from './identifiers';
+import {Identifiers, createIdentifier} 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 resolveIdentifier(Identifiers.Renderer); };
+  get renderer() { return createIdentifier(Identifiers.Renderer); };
   renderText: any = null;
   renderElement: any = null;
   renderComment: any = null;

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

@@ -8,11 +8,12 @@
 
 import {Component, Directive, HostBinding, HostListener, Injectable, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
 
-import {StringMapWrapper} from './facade/collection';
+import {ListWrapper, StringMapWrapper} from './facade/collection';
 import {stringify} from './facade/lang';
 import {ReflectorReader, reflector} from './private_import_core';
 import {splitAtColon} from './util';
 
+
 /*
  * Resolve a `Type` for {@link Directive}.
  *
@@ -35,7 +36,7 @@ export class DirectiveResolver {
   resolve(type: Type<any>, throwIfNotFound = true): Directive {
     const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
     if (typeMetadata) {
-      const metadata = typeMetadata.find(isDirectiveMetadata);
+      const metadata = ListWrapper.findLast(typeMetadata, isDirectiveMetadata);
       if (metadata) {
         const propertyMetadata = this._reflector.propMetadata(type);
         return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
@@ -58,85 +59,74 @@ export class DirectiveResolver {
     const queries: {[key: string]: any} = {};
 
     Object.keys(propertyMetadata).forEach((propName: string) => {
-
-      propertyMetadata[propName].forEach(a => {
-        if (a instanceof Input) {
-          if (a.bindingPropertyName) {
-            inputs.push(`${propName}: ${a.bindingPropertyName}`);
-          } else {
-            inputs.push(propName);
+      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>'.`);
           }
-        } 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;
+          host[`[${hostBinding.hostPropertyName}]`] = propName;
+        } else {
+          host[`[${propName}]`] = propName;
         }
       });
+      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: 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 mergedInputs =
+        this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);
+    const mergedOutputs =
+        this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);
     const mergedHost = directive.host ? StringMapWrapper.merge(directive.host, host) : host;
     const mergedQueries =
         directive.queries ? StringMapWrapper.merge(directive.queries, queries) : queries;

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

@@ -8,13 +8,13 @@
 
 import {Injectable} from '@angular/core';
 
-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata} from './compile_metadata';
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
 import {createCheckBindingField, createCheckBindingStmt} from './compiler_util/binding_util';
 import {EventHandlerVars, convertActionBinding, convertPropertyBinding} from './compiler_util/expression_converter';
 import {triggerAnimation, writeToRenderer} from './compiler_util/render_util';
 import {CompilerConfig} from './config';
 import {Parser} from './expression_parser/parser';
-import {Identifiers, resolveIdentifier} from './identifiers';
+import {Identifiers, createIdentifier} 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';
@@ -53,7 +53,9 @@ const RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap
  */
 @Injectable()
 export class DirectiveWrapperCompiler {
-  static dirWrapperClassName(id: CompileIdentifierMetadata) { return `Wrapper_${id.name}`; }
+  static dirWrapperClassName(id: CompileIdentifierMetadata) {
+    return `Wrapper_${identifierName(id)}`;
+  }
 
   constructor(
       private compilerConfig: CompilerConfig, private _exprParser: Parser,
@@ -68,7 +70,7 @@ export class DirectiveWrapperCompiler {
       addCheckInputMethod(inputFieldName, builder);
     });
     addNgDoCheckMethod(builder);
-    addCheckHostMethod(hostParseResult.hostProps, builder);
+    addCheckHostMethod(hostParseResult.hostProps, hostParseResult.hostListeners, builder);
     addHandleEventMethod(hostParseResult.hostListeners, builder);
     addSubscribeMethod(dirMeta, builder);
 
@@ -117,10 +119,10 @@ class DirectiveWrapperBuilder implements ClassBuilder {
           [
             new o.FnParam(
                 VIEW_VAR.name,
-                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
             new o.FnParam(
                 COMPONENT_VIEW_VAR.name,
-                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
             new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
           ],
           this.detachStmts),
@@ -172,7 +174,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
     }
     if (builder.compilerConfig.logBindingUpdate) {
       onChangesStmts.push(
-          o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfoForChanges))
+          o.importExpr(createIdentifier(Identifiers.setBindingDebugInfoForChanges))
               .callFn(
                   [VIEW_VAR.prop('renderer'), RENDER_EL_VAR, o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])
               .toStmt());
@@ -198,7 +200,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
       'ngDoCheck',
       [
         new o.FnParam(
-            VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+            VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
         new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
         new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
       ],
@@ -214,7 +216,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(resolveIdentifier(Identifiers.SimpleChange))
+                                .set(o.importExpr(createIdentifier(Identifiers.SimpleChange))
                                          .instantiate([field.expression, CURR_VALUE_VAR]))
                                 .toStmt());
   }
@@ -233,14 +235,15 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
 }
 
 function addCheckHostMethod(
-    hostProps: BoundElementPropertyAst[], builder: DirectiveWrapperBuilder) {
+    hostProps: BoundElementPropertyAst[], hostEvents: BoundEventAst[],
+    builder: DirectiveWrapperBuilder) {
   const stmts: o.Statement[] = [];
   const methodParams: o.FnParam[] = [
     new o.FnParam(
-        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(
         COMPONENT_VIEW_VAR.name,
-        o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
     new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
   ];
@@ -255,14 +258,14 @@ function addCheckHostMethod(
     if (hostProp.needsRuntimeSecurityContext) {
       securityContextExpr = o.variable(`secCtx_${methodParams.length}`);
       methodParams.push(new o.FnParam(
-          securityContextExpr.name, o.importType(resolveIdentifier(Identifiers.SecurityContext))));
+          securityContextExpr.name, o.importType(createIdentifier(Identifiers.SecurityContext))));
     }
     let checkBindingStmts: o.Statement[];
     if (hostProp.isAnimation) {
       const {updateStmts, detachStmts} = triggerAnimation(
-          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp,
+          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp, hostEvents,
           o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME)
-              .or(o.importExpr(resolveIdentifier(Identifiers.noop))),
+              .or(o.importExpr(createIdentifier(Identifiers.noop))),
           RENDER_EL_VAR, evalResult.currValExpr, field.expression);
       checkBindingStmts = updateStmts;
       builder.detachStmts.push(...detachStmts);
@@ -306,7 +309,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(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(EVENT_HANDLER_FIELD_NAME, o.DYNAMIC_TYPE)
   ];
   const stmts: o.Statement[] = [
@@ -348,9 +351,10 @@ function parseHostBindings(
   const errors: ParseError[] = [];
   const parser =
       new BindingParser(exprParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors);
-  const sourceFileName = dirMeta.type.moduleUrl ?
-      `in Directive ${dirMeta.type.name} in ${dirMeta.type.moduleUrl}` :
-      `in Directive ${dirMeta.type.name}`;
+  const moduleUrl = identifierModuleUrl(dirMeta.type);
+  const sourceFileName = moduleUrl ?
+      `in Directive ${identifierName(dirMeta.type)} in ${moduleUrl}` :
+      `in Directive ${identifierName(dirMeta.type)}`;
   const sourceFile = new ParseSourceFile('', sourceFileName);
   const sourceSpan = new ParseSourceSpan(
       new ParseLocation(sourceFile, null, null, null),

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

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

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

@@ -12,9 +12,10 @@
  */
 import {ViewEncapsulation} from '@angular/core';
 
-import {analyzeAndValidateNgModules, extractProgramSymbols, loadNgModuleDirectives} from '../aot/compiler';
+import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
 import {StaticAndDynamicReflectionCapabilities} from '../aot/static_reflection_capabilities';
 import {StaticReflector, StaticReflectorHost} from '../aot/static_reflector';
+import {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
 import {CompileDirectiveMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import {DirectiveNormalizer} from '../directive_normalizer';
@@ -41,7 +42,7 @@ export interface ExtractorOptions {
  * The host of the Extractor disconnects the implementation from TypeScript / other language
  * services and from underlying file systems.
  */
-export interface ExtractorHost extends StaticReflectorHost {
+export interface ExtractorHost extends StaticReflectorHost, AotSummaryResolverHost {
   /**
    * Loads a resource (e.g. html / css)
    */
@@ -58,32 +59,36 @@ export class Extractor {
     const programSymbols = extractProgramSymbols(this.staticReflector, rootFiles, this.options);
     const {ngModuleByPipeOrDirective, files, ngModules} =
         analyzeAndValidateNgModules(programSymbols, this.options, this.metadataResolver);
-    return loadNgModuleDirectives(ngModules).then(() => {
-      const errors: ParseError[] = [];
+    return Promise
+        .all(ngModules.map(
+            ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
+                ngModule.type.reference, false)))
+        .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);
+          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'));
           }
-        });
-        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;
-    });
+          return this.messageBundle;
+        });
   }
 
   static create(host: ExtractorHost, options: ExtractorOptions):
@@ -106,7 +111,8 @@ export class Extractor {
     const elementSchemaRegistry = new DomElementSchemaRegistry();
     const resolver = new CompileMetadataResolver(
         new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-        new PipeResolver(staticReflector), elementSchemaRegistry, normalizer, staticReflector);
+        new PipeResolver(staticReflector), new AotSummaryResolver(host, staticReflector, options),
+        elementSchemaRegistry, normalizer, staticReflector);
 
     // TODO(vicb): implicit tags & attributes
     const messageBundle = new MessageBundle(htmlParser, [], {});

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

@@ -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, isStaticSymbol} from './aot/static_symbol';
-import {CompileIdentifierMetadata, CompileTokenMetadata} from './compile_metadata';
+import {StaticSymbol} from './aot/static_symbol';
+import {CompileIdentifierMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
 import {AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, ComponentRef_, DebugAppView, DebugContext, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, 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,27 +347,25 @@ export function assetUrl(pkg: string, path: string = null, type: string = 'src')
 }
 
 export function resolveIdentifier(identifier: IdentifierSpec) {
-  let moduleUrl = identifier.moduleUrl;
+  return reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);
+}
+
+export function createIdentifier(identifier: IdentifierSpec): CompileIdentifierMetadata {
   const reference =
       reflector.resolveIdentifier(identifier.name, identifier.moduleUrl, identifier.runtime);
-  if (isStaticSymbol(reference)) {
-    moduleUrl = reference.filePath;
-  }
-  return new CompileIdentifierMetadata(
-      {name: identifier.name, moduleUrl: moduleUrl, reference: reference});
+  return {reference: reference};
 }
 
 export function identifierToken(identifier: CompileIdentifierMetadata): CompileTokenMetadata {
-  return new CompileTokenMetadata({identifier: identifier});
+  return {identifier: identifier};
 }
 
-export function resolveIdentifierToken(identifier: IdentifierSpec): CompileTokenMetadata {
-  return identifierToken(resolveIdentifier(identifier));
+export function createIdentifierToken(identifier: IdentifierSpec): CompileTokenMetadata {
+  return identifierToken(createIdentifier(identifier));
 }
 
-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});
+export function createEnumIdentifier(
+    enumType: IdentifierSpec, name: string): CompileIdentifierMetadata {
+  const resolvedEnum = reflector.resolveEnum(resolveIdentifier(enumType), name);
+  return {reference: resolvedEnum};
 }

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

@@ -10,7 +10,7 @@ import {Compiler, ComponentFactory, Injectable, Injector, ModuleWithComponentFac
 
 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, ProviderMeta, createHostComponentMeta} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, ProviderMeta, createHostComponentMeta, identifierName} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import {DirectiveNormalizer} from '../directive_normalizer';
 import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
@@ -70,6 +70,14 @@ export class JitCompiler implements Compiler {
     return this._compileModuleAndAllComponents(moduleType, false).asyncResult;
   }
 
+  getNgContentSelectors(component: Type<any>): string[] {
+    const template = this._compiledTemplateCache.get(component);
+    if (!template) {
+      throw new Error(`The component ${stringify(component)} is not yet compiled!`);
+    }
+    return template.compMeta.template.ngContentSelectors;
+  }
+
   private _compileModuleAndComponents<T>(moduleType: Type<T>, isSync: boolean):
       SyncAsyncResult<NgModuleFactory<T>> {
     const loadingPromise = this._loadModules(moduleType, isSync);
@@ -101,16 +109,14 @@ export class JitCompiler implements Compiler {
 
   private _loadModules(mainModule: any, isSync: boolean): Promise<any> {
     const loadingPromises: Promise<any>[] = [];
-    const {ngModule, loading} = this._metadataResolver.loadNgModuleMetadata(mainModule, isSync);
-    loadingPromises.push(loading);
+    const ngModule = this._metadataResolver.getNgModuleMetadata(mainModule);
     // Note: the loadingPromise for a module only includes the loading of the exported directives
     // of imported modules.
     // However, for runtime compilation, we want to transitively compile all modules,
     // so we also need to call loadNgModuleMetadata for all nested modules.
     ngModule.transitiveModule.modules.forEach((localModuleMeta) => {
-      loadingPromises.push(
-          this._metadataResolver.loadNgModuleMetadata(localModuleMeta.type.reference, isSync)
-              .loading);
+      loadingPromises.push(this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
+          localModuleMeta.reference, isSync));
     });
     return Promise.all(loadingPromises);
   }
@@ -126,14 +132,13 @@ export class JitCompiler implements Compiler {
       compileResult.dependencies.forEach((dep) => {
         dep.placeholder.reference =
             this._assertComponentKnown(dep.comp.reference, true).proxyComponentFactory;
-        dep.placeholder.name = `compFactory_${dep.comp.name}`;
       });
       if (!this._compilerConfig.useJit) {
         ngModuleFactory =
             interpretStatements(compileResult.statements, compileResult.ngModuleFactoryVar);
       } else {
         ngModuleFactory = jitStatements(
-            `/${moduleMeta.type.name}/module.ngfactory.js`, compileResult.statements,
+            `/${identifierName(moduleMeta.type)}/module.ngfactory.js`, compileResult.statements,
             compileResult.ngModuleFactoryVar);
       }
       this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory);
@@ -151,7 +156,7 @@ export class JitCompiler implements Compiler {
 
     ngModule.transitiveModule.modules.forEach((localModuleSummary) => {
       const localModuleMeta =
-          this._metadataResolver.getNgModuleMetadata(localModuleSummary.type.reference);
+          this._metadataResolver.getNgModuleMetadata(localModuleSummary.reference);
       localModuleMeta.declaredDirectives.forEach((dirIdentifier) => {
         moduleByDirective.set(dirIdentifier.reference, localModuleMeta);
         const dirMeta = this._metadataResolver.getDirectiveMetadata(dirIdentifier.reference);
@@ -169,7 +174,7 @@ export class JitCompiler implements Compiler {
     });
     ngModule.transitiveModule.modules.forEach((localModuleSummary) => {
       const localModuleMeta =
-          this._metadataResolver.getNgModuleMetadata(localModuleSummary.type.reference);
+          this._metadataResolver.getNgModuleMetadata(localModuleSummary.reference);
       localModuleMeta.declaredDirectives.forEach((dirIdentifier) => {
         const dirMeta = this._metadataResolver.getDirectiveMetadata(dirIdentifier.reference);
         if (dirMeta.isComponent) {
@@ -215,7 +220,11 @@ export class JitCompiler implements Compiler {
     if (!compiledTemplate) {
       const compMeta = this._metadataResolver.getDirectiveMetadata(compType);
       assertComponent(compMeta);
-      const hostMeta = createHostComponentMeta(compMeta);
+
+      const HostClass = function HostClass() {};
+      (<any>HostClass).overriddenName = `${identifierName(compMeta.type)}_Host`;
+
+      const hostMeta = createHostComponentMeta(HostClass, compMeta);
       compiledTemplate = new CompiledTemplate(
           true, compMeta.selector, compMeta.type, hostMeta, ngModule, [compMeta.type]);
       this._compiledHostTemplateCache.set(compType, compiledTemplate);
@@ -264,8 +273,8 @@ export class JitCompiler implements Compiler {
       directiveWrapperClass = interpretStatements(statements, compileResult.dirWrapperClassVar);
     } else {
       directiveWrapperClass = jitStatements(
-          `/${moduleMeta.type.name}/${dirMeta.type.name}/wrapper.ngfactory.js`, statements,
-          compileResult.dirWrapperClassVar);
+          `/${identifierName(moduleMeta.type)}/${identifierName(dirMeta.type)}/wrapper.ngfactory.js`,
+          statements, compileResult.dirWrapperClassVar);
     }
     this._compiledDirectiveWrapperCache.set(dirMeta.type.reference, directiveWrapperClass);
   }
@@ -288,9 +297,9 @@ export class JitCompiler implements Compiler {
         pipe => this._metadataResolver.getPipeSummary(pipe.reference));
     const parsedTemplate = this._templateParser.parse(
         compMeta, compMeta.template.template, directives, pipes, template.ngModule.schemas,
-        compMeta.type.name);
+        identifierName(compMeta.type));
     const compiledAnimations =
-        this._animationCompiler.compile(compMeta.type.name, parsedAnimations);
+        this._animationCompiler.compile(identifierName(compMeta.type), parsedAnimations);
     const compileResult = this._viewCompiler.compileComponent(
         compMeta, parsedTemplate, ir.variable(stylesCompileResult.componentStylesheet.stylesVar),
         pipes, compiledAnimations);
@@ -300,12 +309,10 @@ export class JitCompiler implements Compiler {
         const vfd = <ViewClassDependency>dep;
         depTemplate = this._assertComponentKnown(vfd.comp.reference, false);
         vfd.placeholder.reference = depTemplate.proxyViewClass;
-        vfd.placeholder.name = `View_${vfd.comp.name}`;
       } else if (dep instanceof ComponentFactoryDependency) {
         const cfd = <ComponentFactoryDependency>dep;
         depTemplate = this._assertComponentKnown(cfd.comp.reference, true);
         cfd.placeholder.reference = depTemplate.proxyComponentFactory;
-        cfd.placeholder.name = `compFactory_${cfd.comp.name}`;
       } else if (dep instanceof DirectiveWrapperDependency) {
         const dwd = <DirectiveWrapperDependency>dep;
         dwd.placeholder.reference = this._assertDirectiveWrapper(dwd.dir.reference);
@@ -319,7 +326,7 @@ export class JitCompiler implements Compiler {
       viewClass = interpretStatements(statements, compileResult.viewClassVar);
     } else {
       viewClass = jitStatements(
-          `/${template.ngModule.type.name}/${template.compType.name}/${template.isHost?'host':'component'}.ngfactory.js`,
+          `/${identifierName(template.ngModule.type)}/${identifierName(template.compType)}/${template.isHost?'host':'component'}.ngfactory.js`,
           statements, compileResult.viewClassVar);
     }
     template.compiled(viewClass);
@@ -332,7 +339,6 @@ export class JitCompiler implements Compiler {
       const nestedStylesArr = this._resolveAndEvalStylesCompileResult(
           nestedCompileResult, externalStylesheetsByModuleUrl);
       dep.valuePlaceholder.reference = nestedStylesArr;
-      dep.valuePlaceholder.name = `importedStyles${i}`;
     });
   }
 
@@ -343,7 +349,8 @@ export class JitCompiler implements Compiler {
     if (!this._compilerConfig.useJit) {
       return interpretStatements(result.statements, result.stylesVar);
     } else {
-      return jitStatements(`/${result.meta.moduleUrl}.css.js`, result.statements, result.stylesVar);
+      return jitStatements(
+          `/${result.meta.moduleUrl}.ngstyle.js`, result.statements, result.stylesVar);
     }
   }
 }
@@ -380,7 +387,8 @@ class CompiledTemplate {
 
 function assertComponent(meta: CompileDirectiveMetadata) {
   if (!meta.isComponent) {
-    throw new Error(`Could not compile '${meta.type.name}' because it is not a component.`);
+    throw new Error(
+        `Could not compile '${identifierName(meta.type)}' because it is not a component.`);
   }
 }
 
@@ -408,6 +416,11 @@ class ModuleBoundCompiler implements Compiler {
     return this._delegate.compileModuleAndAllComponentsAsync(moduleType);
   }
 
+  getNgContentSelectors(component: Type<any>): string[] {
+    return this._delegate.getNgContentSelectors(component);
+  }
+
+
   /**
    * Clears all caches
    */

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

@@ -26,6 +26,7 @@ import {ResourceLoader} from '../resource_loader';
 import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {StyleCompiler} from '../style_compiler';
+import {SummaryResolver} from '../summary_resolver';
 import {TemplateParser} from '../template_parser/template_parser';
 import {DEFAULT_PACKAGE_URL_PROVIDER, UrlResolver} from '../url_resolver';
 import {ViewCompiler} from '../view_compiler/view_compiler';
@@ -46,6 +47,7 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
   {provide: Reflector, useValue: reflector},
   {provide: ReflectorReader, useExisting: Reflector},
   {provide: ResourceLoader, useValue: _NO_RESOURCE_LOADER},
+  SummaryResolver,
   Console,
   Lexer,
   Parser,

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

@@ -6,25 +6,27 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AnimationAnimateMetadata, AnimationEntryMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationStateDeclarationMetadata, AnimationStateMetadata, AnimationStateTransitionMetadata, AnimationStyleMetadata, AnimationWithStepsMetadata, Attribute, ChangeDetectionStrategy, Component, Host, Inject, Injectable, ModuleWithProviders, Optional, Provider, Query, SchemaMetadata, Self, SkipSelf, Type, resolveForwardRef} from '@angular/core';
+import {AnimationAnimateMetadata, AnimationEntryMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationStateDeclarationMetadata, AnimationStateMetadata, AnimationStateTransitionMetadata, AnimationStyleMetadata, AnimationWithStepsMetadata, Attribute, ChangeDetectionStrategy, Component, Directive, Host, Inject, Injectable, ModuleWithProviders, OpaqueToken, Optional, Provider, Query, SchemaMetadata, Self, SkipSelf, Type, resolveForwardRef} from '@angular/core';
 
-import {isStaticSymbol} from './aot/static_symbol';
+import {StaticSymbol} from './aot/static_symbol';
 import {assertArrayOfStrings, assertInterpolationSymbols} from './assertions';
 import * as cpl from './compile_metadata';
 import {DirectiveNormalizer} from './directive_normalizer';
 import {DirectiveResolver} from './directive_resolver';
 import {ListWrapper, StringMapWrapper} from './facade/collection';
 import {isBlank, isPresent, stringify} from './facade/lang';
-import {Identifiers, resolveIdentifierToken} from './identifiers';
+import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
 import {hasLifecycleHook} from './lifecycle_reflector';
 import {NgModuleResolver} from './ng_module_resolver';
 import {PipeResolver} from './pipe_resolver';
 import {ComponentStillLoadingError, LIFECYCLE_HOOKS_VALUES, ReflectorReader, reflector} from './private_import_core';
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
+import {SummaryResolver} from './summary_resolver';
 import {getUrlScheme} from './url_resolver';
-import {MODULE_SUFFIX, SyncAsyncResult, ValueTransformer, sanitizeIdentifier, visitValue} from './util';
-
+import {MODULE_SUFFIX, SyncAsyncResult, ValueTransformer, visitValue} from './util';
 
+export type ErrorCollector = (error: any, type?: any) => void;
+export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
 
 // Design notes:
 // - don't lazily create metadata:
@@ -36,40 +38,24 @@ import {MODULE_SUFFIX, SyncAsyncResult, ValueTransformer, sanitizeIdentifier, vi
 @Injectable()
 export class CompileMetadataResolver {
   private _directiveCache = new Map<Type<any>, cpl.CompileDirectiveMetadata>();
-  private _directiveSummaryCache = new Map<Type<any>, cpl.CompileDirectiveSummary>();
+  private _summaryCache = new Map<Type<any>, cpl.CompileTypeSummary>();
   private _pipeCache = new Map<Type<any>, cpl.CompilePipeMetadata>();
-  private _pipeSummaryCache = new Map<Type<any>, cpl.CompilePipeSummary>();
   private _ngModuleCache = new Map<Type<any>, cpl.CompileNgModuleMetadata>();
   private _ngModuleOfTypes = new Map<Type<any>, Type<any>>();
-  private _anonymousTypes = new Map<Object, number>();
-  private _anonymousTypeIndex = 0;
 
   constructor(
       private _ngModuleResolver: NgModuleResolver, private _directiveResolver: DirectiveResolver,
-      private _pipeResolver: PipeResolver, private _schemaRegistry: ElementSchemaRegistry,
+      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver,
+      private _schemaRegistry: ElementSchemaRegistry,
       private _directiveNormalizer: DirectiveNormalizer,
-      private _reflector: ReflectorReader = reflector) {}
-
-  private sanitizeTokenName(token: any): string {
-    let identifier = stringify(token);
-    if (identifier.indexOf('(') >= 0) {
-      // case: anonymous functions!
-      let found = this._anonymousTypes.get(token);
-      if (!found) {
-        this._anonymousTypes.set(token, this._anonymousTypeIndex++);
-        found = this._anonymousTypes.get(token);
-      }
-      identifier = `anonymous_token_${found}_`;
-    }
-    return sanitizeIdentifier(identifier);
-  }
+      private _reflector: ReflectorReader = reflector,
+      @Optional() @Inject(ERROR_COLLECTOR_TOKEN) private _errorCollector?: ErrorCollector) {}
 
   clearCacheFor(type: Type<any>) {
     const dirMeta = this._directiveCache.get(type);
     this._directiveCache.delete(type);
-    this._directiveSummaryCache.delete(type);
+    this._summaryCache.delete(type);
     this._pipeCache.delete(type);
-    this._pipeSummaryCache.delete(type);
     this._ngModuleOfTypes.delete(type);
     // Clear all of the NgModule as they contain transitive information!
     this._ngModuleCache.clear();
@@ -80,9 +66,8 @@ export class CompileMetadataResolver {
 
   clearCache() {
     this._directiveCache.clear();
-    this._directiveSummaryCache.clear();
+    this._summaryCache.clear();
     this._pipeCache.clear();
-    this._pipeSummaryCache.clear();
     this._ngModuleCache.clear();
     this._ngModuleOfTypes.clear();
     this._directiveNormalizer.clearCache();
@@ -142,55 +127,65 @@ export class CompileMetadataResolver {
     return null;
   }
 
+  private _loadSummary(type: any, kind: cpl.CompileSummaryKind): cpl.CompileTypeSummary {
+    let summary = this._summaryCache.get(type);
+    if (!summary) {
+      summary = this._summaryResolver.resolveSummary(type);
+      this._summaryCache.set(type, summary);
+    }
+    return summary && summary.summaryKind === kind ? summary : null;
+  }
+
   private _loadDirectiveMetadata(directiveType: any, isSync: boolean): Promise<any> {
     if (this._directiveCache.has(directiveType)) {
       return;
     }
     directiveType = resolveForwardRef(directiveType);
-    const nonNormalizedMetadata = this.getNonNormalizedDirectiveMetadata(directiveType);
+    const {annotation, metadata} = this.getNonNormalizedDirectiveMetadata(directiveType);
 
     const createDirectiveMetadata = (templateMetadata: cpl.CompileTemplateMetadata) => {
       const normalizedDirMeta = new cpl.CompileDirectiveMetadata({
-        type: nonNormalizedMetadata.type,
-        isComponent: nonNormalizedMetadata.isComponent,
-        selector: nonNormalizedMetadata.selector,
-        exportAs: nonNormalizedMetadata.exportAs,
-        changeDetection: nonNormalizedMetadata.changeDetection,
-        inputs: nonNormalizedMetadata.inputs,
-        outputs: nonNormalizedMetadata.outputs,
-        hostListeners: nonNormalizedMetadata.hostListeners,
-        hostProperties: nonNormalizedMetadata.hostProperties,
-        hostAttributes: nonNormalizedMetadata.hostAttributes,
-        providers: nonNormalizedMetadata.providers,
-        viewProviders: nonNormalizedMetadata.viewProviders,
-        queries: nonNormalizedMetadata.queries,
-        viewQueries: nonNormalizedMetadata.viewQueries,
-        entryComponents: nonNormalizedMetadata.entryComponents,
+        type: metadata.type,
+        isComponent: metadata.isComponent,
+        selector: metadata.selector,
+        exportAs: metadata.exportAs,
+        changeDetection: metadata.changeDetection,
+        inputs: metadata.inputs,
+        outputs: metadata.outputs,
+        hostListeners: metadata.hostListeners,
+        hostProperties: metadata.hostProperties,
+        hostAttributes: metadata.hostAttributes,
+        providers: metadata.providers,
+        viewProviders: metadata.viewProviders,
+        queries: metadata.queries,
+        viewQueries: metadata.viewQueries,
+        entryComponents: metadata.entryComponents,
         template: templateMetadata
       });
       this._directiveCache.set(directiveType, normalizedDirMeta);
-      this._directiveSummaryCache.set(directiveType, normalizedDirMeta.toSummary());
+      this._summaryCache.set(directiveType, normalizedDirMeta.toSummary());
       return normalizedDirMeta;
     };
 
-    if (nonNormalizedMetadata.isComponent) {
+    if (metadata.isComponent) {
       const templateMeta = this._directiveNormalizer.normalizeTemplate({
         componentType: directiveType,
-        moduleUrl: nonNormalizedMetadata.type.moduleUrl,
-        encapsulation: nonNormalizedMetadata.template.encapsulation,
-        template: nonNormalizedMetadata.template.template,
-        templateUrl: nonNormalizedMetadata.template.templateUrl,
-        styles: nonNormalizedMetadata.template.styles,
-        styleUrls: nonNormalizedMetadata.template.styleUrls,
-        animations: nonNormalizedMetadata.template.animations,
-        interpolation: nonNormalizedMetadata.template.interpolation
+        moduleUrl: componentModuleUrl(this._reflector, directiveType, annotation),
+        encapsulation: metadata.template.encapsulation,
+        template: metadata.template.template,
+        templateUrl: metadata.template.templateUrl,
+        styles: metadata.template.styles,
+        styleUrls: metadata.template.styleUrls,
+        animations: metadata.template.animations,
+        interpolation: metadata.template.interpolation
       });
       if (templateMeta.syncResult) {
         createDirectiveMetadata(templateMeta.syncResult);
         return null;
       } else {
         if (isSync) {
-          throw new ComponentStillLoadingError(directiveType);
+          this._reportError(new ComponentStillLoadingError(directiveType), directiveType);
+          return null;
         }
         return templateMeta.asyncResult.then(createDirectiveMetadata);
       }
@@ -201,18 +196,17 @@ export class CompileMetadataResolver {
     }
   }
 
-  getNonNormalizedDirectiveMetadata(directiveType: any): cpl.CompileDirectiveMetadata {
+  getNonNormalizedDirectiveMetadata(directiveType: any):
+      {annotation: Directive, metadata: cpl.CompileDirectiveMetadata} {
     directiveType = resolveForwardRef(directiveType);
     const dirMeta = this._directiveResolver.resolve(directiveType);
     if (!dirMeta) {
       return null;
     }
-    let moduleUrl = staticTypeModuleUrl(directiveType);
     let nonNormalizedTemplateMetadata: cpl.CompileTemplateMetadata;
 
     if (dirMeta instanceof Component) {
       // component
-      moduleUrl = componentModuleUrl(this._reflector, directiveType, dirMeta);
       assertArrayOfStrings('styles', dirMeta.styles);
       assertArrayOfStrings('styleUrls', dirMeta.styleUrls);
       assertInterpolationSymbols('interpolation', dirMeta.interpolation);
@@ -233,7 +227,7 @@ export class CompileMetadataResolver {
     }
 
     let changeDetectionStrategy: ChangeDetectionStrategy = null;
-    let viewProviders: Array<cpl.CompileProviderMetadata|cpl.CompileTypeMetadata|any[]> = [];
+    let viewProviders: cpl.CompileProviderMetadata[] = [];
     let entryComponentMetadata: cpl.CompileIdentifierMetadata[] = [];
     let selector = dirMeta.selector;
 
@@ -243,13 +237,12 @@ export class CompileMetadataResolver {
       if (dirMeta.viewProviders) {
         viewProviders = this._getProvidersMetadata(
             dirMeta.viewProviders, entryComponentMetadata,
-            `viewProviders for "${stringify(directiveType)}"`);
+            `viewProviders for "${stringify(directiveType)}"`, [], directiveType);
       }
       if (dirMeta.entryComponents) {
-        entryComponentMetadata =
-            flattenAndDedupeArray(dirMeta.entryComponents)
-                .map((type) => this._getIdentifierMetadata(type, staticTypeModuleUrl(type)))
-                .concat(entryComponentMetadata);
+        entryComponentMetadata = flattenAndDedupeArray(dirMeta.entryComponents)
+                                     .map((type) => this._getIdentifierMetadata(type))
+                                     .concat(entryComponentMetadata);
       }
       if (!selector) {
         selector = this._schemaRegistry.getDefaultComponentElementName();
@@ -257,14 +250,18 @@ export class CompileMetadataResolver {
     } else {
       // Directive
       if (!selector) {
-        throw new Error(`Directive ${stringify(directiveType)} has no selector, please add it!`);
+        this._reportError(
+            new Error(`Directive ${stringify(directiveType)} has no selector, please add it!`),
+            directiveType);
+        selector = 'error';
       }
     }
 
-    let providers: Array<cpl.CompileProviderMetadata|cpl.CompileTypeMetadata|any[]> = [];
+    let providers: cpl.CompileProviderMetadata[] = [];
     if (isPresent(dirMeta.providers)) {
       providers = this._getProvidersMetadata(
-          dirMeta.providers, entryComponentMetadata, `providers for "${stringify(directiveType)}"`);
+          dirMeta.providers, entryComponentMetadata, `providers for "${stringify(directiveType)}"`,
+          [], directiveType);
     }
     let queries: cpl.CompileQueryMetadata[] = [];
     let viewQueries: cpl.CompileQueryMetadata[] = [];
@@ -273,11 +270,11 @@ export class CompileMetadataResolver {
       viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);
     }
 
-    return cpl.CompileDirectiveMetadata.create({
+    const metadata = cpl.CompileDirectiveMetadata.create({
       selector: selector,
       exportAs: dirMeta.exportAs,
       isComponent: !!nonNormalizedTemplateMetadata,
-      type: this._getTypeMetadata(directiveType, moduleUrl),
+      type: this._getTypeMetadata(directiveType),
       template: nonNormalizedTemplateMetadata,
       changeDetection: changeDetectionStrategy,
       inputs: dirMeta.inputs,
@@ -289,6 +286,7 @@ export class CompileMetadataResolver {
       viewQueries: viewQueries,
       entryComponents: entryComponentMetadata
     });
+    return {metadata, annotation: dirMeta};
   }
 
   /**
@@ -298,17 +296,22 @@ export class CompileMetadataResolver {
   getDirectiveMetadata(directiveType: any): cpl.CompileDirectiveMetadata {
     const dirMeta = this._directiveCache.get(directiveType);
     if (!dirMeta) {
-      throw new Error(
-          `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringify(directiveType)}.`);
+      this._reportError(
+          new Error(
+              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringify(directiveType)}.`),
+          directiveType);
     }
     return dirMeta;
   }
 
   getDirectiveSummary(dirType: any): cpl.CompileDirectiveSummary {
-    const dirSummary = this._directiveSummaryCache.get(dirType);
+    const dirSummary =
+        <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
     if (!dirSummary) {
-      throw new Error(
-          `Illegal state: getDirectiveSummary can only be called after loadNgModuleMetadata for a module that imports it. Directive ${stringify(dirType)}.`);
+      this._reportError(
+          new Error(
+              `Illegal state: Could not load the summary for directive ${stringify(dirType)}.`),
+          dirType);
     }
     return dirSummary;
   }
@@ -317,51 +320,39 @@ export class CompileMetadataResolver {
 
   isPipe(type: any) { return this._pipeResolver.isPipe(type); }
 
-  /**
-   * Gets the metadata for the given module.
-   * This assumes `loadNgModuleMetadata` has been called first.
-   */
-  getNgModuleMetadata(moduleType: any): cpl.CompileNgModuleMetadata {
-    const modMeta = this._ngModuleCache.get(moduleType);
-    if (!modMeta) {
-      throw new Error(
-          `Illegal state: getNgModuleMetadata can only be called after loadNgModuleMetadata. Module ${stringify(moduleType)}.`);
+  getNgModuleSummary(moduleType: any): cpl.CompileNgModuleSummary {
+    let moduleSummary =
+        <cpl.CompileNgModuleSummary>this._loadSummary(moduleType, cpl.CompileSummaryKind.NgModule);
+    if (!moduleSummary) {
+      const moduleMeta = this.getNgModuleMetadata(moduleType, false);
+      moduleSummary = moduleMeta ? moduleMeta.toSummary() : null;
+      if (moduleSummary) {
+        this._summaryCache.set(moduleType, moduleSummary);
+      }
     }
-    return modMeta;
-  }
-
-  private _loadNgModuleSummary(moduleType: any, isSync: boolean): cpl.CompileNgModuleSummary {
-    // TODO(tbosch): add logic to read summary files!
-    // - needs to add directive / pipe summaries to this._directiveSummaryCache /
-    // this._pipeSummaryCache as well!
-    const moduleMeta = this._loadNgModuleMetadata(moduleType, isSync, false);
-    return moduleMeta ? moduleMeta.toSummary() : null;
+    return moduleSummary;
   }
 
   /**
-   * Loads an NgModule and all of its directives. This includes loading the exported directives of
-   * imported modules,
-   * but not private directives of imported modules.
+   * Loads the declared directives and pipes of an NgModule.
    */
-  loadNgModuleMetadata(moduleType: any, isSync: boolean, throwIfNotFound = true):
-      {ngModule: cpl.CompileNgModuleMetadata, loading: Promise<any>} {
-    const ngModule = this._loadNgModuleMetadata(moduleType, isSync, throwIfNotFound);
-    const loading = ngModule ?
-        Promise.all(ngModule.transitiveModule.directiveLoaders.map(loader => loader())) :
-        Promise.resolve(null);
-    return {ngModule, loading};
+  loadNgModuleDirectiveAndPipeMetadata(moduleType: any, isSync: boolean, throwIfNotFound = true):
+      Promise<any> {
+    const ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound);
+    const loading: Promise<any>[] = [];
+    if (ngModule) {
+      ngModule.declaredDirectives.forEach((id) => {
+        const promise = this._loadDirectiveMetadata(id.reference, isSync);
+        if (promise) {
+          loading.push(promise);
+        }
+      });
+      ngModule.declaredPipes.forEach((id) => this._loadPipeMetadata(id.reference));
+    }
+    return Promise.all(loading);
   }
 
-  /**
-   * Get the NgModule metadata without loading the directives.
-   */
-  getUnloadedNgModuleMetadata(moduleType: any, isSync: boolean, throwIfNotFound = true):
-      cpl.CompileNgModuleMetadata {
-    return this._loadNgModuleMetadata(moduleType, isSync, throwIfNotFound);
-  }
-
-  private _loadNgModuleMetadata(moduleType: any, isSync: boolean, throwIfNotFound = true):
-      cpl.CompileNgModuleMetadata {
+  getNgModuleMetadata(moduleType: any, throwIfNotFound = true): cpl.CompileNgModuleMetadata {
     moduleType = resolveForwardRef(moduleType);
     let compileMeta = this._ngModuleCache.get(moduleType);
     if (compileMeta) {
@@ -376,7 +367,7 @@ export class CompileMetadataResolver {
     const declaredPipes: cpl.CompileIdentifierMetadata[] = [];
     const importedModules: cpl.CompileNgModuleSummary[] = [];
     const exportedModules: cpl.CompileNgModuleSummary[] = [];
-    const providers: any[] = [];
+    const providers: cpl.CompileProviderMetadata[] = [];
     const entryComponents: cpl.CompileIdentifierMetadata[] = [];
     const bootstrapComponents: cpl.CompileIdentifierMetadata[] = [];
     const schemas: SchemaMetadata[] = [];
@@ -392,20 +383,26 @@ export class CompileMetadataResolver {
           if (moduleWithProviders.providers) {
             providers.push(...this._getProvidersMetadata(
                 moduleWithProviders.providers, entryComponents,
-                `provider for the NgModule '${stringify(importedModuleType)}'`));
+                `provider for the NgModule '${stringify(importedModuleType)}'`, [], importedType));
           }
         }
 
         if (importedModuleType) {
-          const importedModuleSummary = this._loadNgModuleSummary(importedModuleType, isSync);
+          const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
           if (!importedModuleSummary) {
-            throw new Error(
-                `Unexpected ${this._getTypeDescriptor(importedType)} '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`);
+            this._reportError(
+                new Error(
+                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
+                moduleType);
+            return;
           }
           importedModules.push(importedModuleSummary);
         } else {
-          throw new Error(
-              `Unexpected value '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`);
+          this._reportError(
+              new Error(
+                  `Unexpected value '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
+              moduleType);
+          return;
         }
       });
     }
@@ -413,15 +410,17 @@ export class CompileMetadataResolver {
     if (meta.exports) {
       flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
         if (!isValidType(exportedType)) {
-          throw new Error(
-              `Unexpected value '${stringify(exportedType)}' exported by the module '${stringify(moduleType)}'`);
+          this._reportError(
+              new Error(
+                  `Unexpected value '${stringify(exportedType)}' exported by the module '${stringify(moduleType)}'`),
+              moduleType);
+          return;
         }
-        const exportedModuleSummary = this._loadNgModuleSummary(exportedType, isSync);
+        const exportedModuleSummary = this.getNgModuleSummary(exportedType);
         if (exportedModuleSummary) {
           exportedModules.push(exportedModuleSummary);
         } else {
-          exportedNonModuleIdentifiers.push(
-              this._getIdentifierMetadata(exportedType, staticTypeModuleUrl(exportedType)));
+          exportedNonModuleIdentifiers.push(this._getIdentifierMetadata(exportedType));
         }
       });
     }
@@ -432,27 +431,28 @@ export class CompileMetadataResolver {
     if (meta.declarations) {
       flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
         if (!isValidType(declaredType)) {
-          throw new Error(
-              `Unexpected value '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`);
+          this._reportError(
+              new Error(
+                  `Unexpected value '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
+              moduleType);
+          return;
         }
-        const declaredIdentifier =
-            this._getIdentifierMetadata(declaredType, staticTypeModuleUrl(declaredType));
+        const declaredIdentifier = this._getIdentifierMetadata(declaredType);
         if (this._directiveResolver.isDirective(declaredType)) {
-          transitiveModule.directivesSet.add(declaredType);
-          transitiveModule.directives.push(declaredIdentifier);
+          transitiveModule.addDirective(declaredIdentifier);
           declaredDirectives.push(declaredIdentifier);
           this._addTypeToModule(declaredType, moduleType);
-          transitiveModule.directiveLoaders.push(
-              () => this._loadDirectiveMetadata(declaredType, isSync));
         } else if (this._pipeResolver.isPipe(declaredType)) {
-          transitiveModule.pipesSet.add(declaredType);
+          transitiveModule.addPipe(declaredIdentifier);
           transitiveModule.pipes.push(declaredIdentifier);
           declaredPipes.push(declaredIdentifier);
           this._addTypeToModule(declaredType, moduleType);
-          this._loadPipeMetadata(declaredType);
         } else {
-          throw new Error(
-              `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`);
+          this._reportError(
+              new Error(
+                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
+              moduleType);
+          return;
         }
       });
     }
@@ -462,11 +462,15 @@ export class CompileMetadataResolver {
     exportedNonModuleIdentifiers.forEach((exportedId) => {
       if (transitiveModule.directivesSet.has(exportedId.reference)) {
         exportedDirectives.push(exportedId);
+        transitiveModule.addExportedDirective(exportedId);
       } else if (transitiveModule.pipesSet.has(exportedId.reference)) {
         exportedPipes.push(exportedId);
+        transitiveModule.addExportedPipe(exportedId);
       } else {
-        throw new Error(
-            `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringify(exportedId.reference)} from ${stringify(moduleType)} as it was neither declared nor imported!`);
+        this._reportError(
+            new Error(
+                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringify(exportedId.reference)} from ${stringify(moduleType)} as it was neither declared nor imported!`),
+            moduleType);
       }
     });
 
@@ -474,24 +478,26 @@ export class CompileMetadataResolver {
     // so that they overwrite any other provider we already added.
     if (meta.providers) {
       providers.push(...this._getProvidersMetadata(
-          meta.providers, entryComponents, `provider for the NgModule '${stringify(moduleType)}'`));
+          meta.providers, entryComponents, `provider for the NgModule '${stringify(moduleType)}'`,
+          [], moduleType));
     }
 
     if (meta.entryComponents) {
       entryComponents.push(
-          ...flattenAndDedupeArray(meta.entryComponents)
-              .map(type => this._getTypeMetadata(type, staticTypeModuleUrl(type))));
+          ...flattenAndDedupeArray(meta.entryComponents).map(type => this._getTypeMetadata(type)));
     }
 
     if (meta.bootstrap) {
-      const typeMetadata = flattenAndDedupeArray(meta.bootstrap).map(type => {
+      flattenAndDedupeArray(meta.bootstrap).forEach(type => {
         if (!isValidType(type)) {
-          throw new Error(
-              `Unexpected value '${stringify(type)}' used in the bootstrap property of module '${stringify(moduleType)}'`);
+          this._reportError(
+              new Error(
+                  `Unexpected value '${stringify(type)}' used in the bootstrap property of module '${stringify(moduleType)}'`),
+              moduleType);
+          return;
         }
-        return this._getTypeMetadata(type, staticTypeModuleUrl(type));
+        bootstrapComponents.push(this._getTypeMetadata(type));
       });
-      bootstrapComponents.push(...typeMetadata);
     }
 
     entryComponents.push(...bootstrapComponents);
@@ -500,11 +506,8 @@ export class CompileMetadataResolver {
       schemas.push(...flattenAndDedupeArray(meta.schemas));
     }
 
-    transitiveModule.entryComponents.push(...entryComponents);
-    transitiveModule.providers.push(...providers);
-
     compileMeta = new cpl.CompileNgModuleMetadata({
-      type: this._getTypeMetadata(moduleType, staticTypeModuleUrl(moduleType)),
+      type: this._getTypeMetadata(moduleType),
       providers,
       entryComponents,
       bootstrapComponents,
@@ -519,7 +522,9 @@ export class CompileMetadataResolver {
       id: meta.id,
     });
 
-    transitiveModule.modules.push(compileMeta.toInjectorSummary());
+    entryComponents.forEach((id) => transitiveModule.addEntryComponent(id));
+    providers.forEach((provider) => transitiveModule.addProvider(provider, compileMeta.type));
+    transitiveModule.addModule(compileMeta.type);
     this._ngModuleCache.set(moduleType, compileMeta);
     return compileMeta;
   }
@@ -548,10 +553,12 @@ export class CompileMetadataResolver {
   private _addTypeToModule(type: Type<any>, moduleType: Type<any>) {
     const oldModule = this._ngModuleOfTypes.get(type);
     if (oldModule && oldModule !== moduleType) {
-      throw new Error(
-          `Type ${stringify(type)} is part of the declarations of 2 modules: ${stringify(oldModule)} and ${stringify(moduleType)}! ` +
-          `Please consider moving ${stringify(type)} to a higher module that imports ${stringify(oldModule)} and ${stringify(moduleType)}. ` +
-          `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${stringify(oldModule)} and ${stringify(moduleType)}.`);
+      this._reportError(
+          new Error(
+              `Type ${stringify(type)} is part of the declarations of 2 modules: ${stringify(oldModule)} and ${stringify(moduleType)}! ` +
+              `Please consider moving ${stringify(type)} to a higher module that imports ${stringify(oldModule)} and ${stringify(moduleType)}. ` +
+              `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${stringify(oldModule)} and ${stringify(moduleType)}.`),
+          moduleType);
     }
     this._ngModuleOfTypes.set(type, moduleType);
   }
@@ -560,50 +567,59 @@ export class CompileMetadataResolver {
       importedModules: cpl.CompileNgModuleSummary[],
       exportedModules: cpl.CompileNgModuleSummary[]): cpl.TransitiveCompileNgModuleMetadata {
     // collect `providers` / `entryComponents` from all imported and all exported modules
-    const transitiveModules = getTransitiveImportedModules(importedModules.concat(exportedModules));
-    const providers = flattenArray(transitiveModules.map((ngModule) => ngModule.providers));
-    const entryComponents =
-        flattenArray(transitiveModules.map((ngModule) => ngModule.entryComponents));
-
-    const transitiveExportedModules = getTransitiveExportedModules(importedModules);
-    const directives =
-        flattenArray(transitiveExportedModules.map((ngModule) => ngModule.exportedDirectives));
-    const pipes = flattenArray(transitiveExportedModules.map((ngModule) => ngModule.exportedPipes));
-    const directiveLoaders =
-        ListWrapper.flatten(transitiveExportedModules.map(ngModule => ngModule.directiveLoaders));
-    return new cpl.TransitiveCompileNgModuleMetadata(
-        transitiveModules, providers, entryComponents, directives, pipes, directiveLoaders);
+    const result = new cpl.TransitiveCompileNgModuleMetadata();
+    const modulesByToken = new Map<any, Set<any>>();
+    importedModules.concat(exportedModules).forEach((modSummary) => {
+      modSummary.modules.forEach((mod) => result.addModule(mod));
+      modSummary.entryComponents.forEach((comp) => result.addEntryComponent(comp));
+      const addedTokens = new Set<any>();
+      modSummary.providers.forEach((entry) => {
+        const tokenRef = cpl.tokenReference(entry.provider.token);
+        let prevModules = modulesByToken.get(tokenRef);
+        if (!prevModules) {
+          prevModules = new Set<any>();
+          modulesByToken.set(tokenRef, prevModules);
+        }
+        const moduleRef = entry.module.reference;
+        // Note: the providers of one module may still contain multiple providers
+        // per token (e.g. for multi providers), and we need to preserve these.
+        if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) {
+          prevModules.add(moduleRef);
+          addedTokens.add(tokenRef);
+          result.addProvider(entry.provider, entry.module);
+        }
+      });
+    });
+    exportedModules.forEach((modSummary) => {
+      modSummary.exportedDirectives.forEach((id) => result.addExportedDirective(id));
+      modSummary.exportedPipes.forEach((id) => result.addExportedPipe(id));
+    });
+    importedModules.forEach((modSummary) => {
+      modSummary.exportedDirectives.forEach((id) => result.addDirective(id));
+      modSummary.exportedPipes.forEach((id) => result.addPipe(id));
+    });
+    return result;
   }
 
-  private _getIdentifierMetadata(type: Type<any>, moduleUrl: string):
-      cpl.CompileIdentifierMetadata {
+  private _getIdentifierMetadata(type: Type<any>): cpl.CompileIdentifierMetadata {
     type = resolveForwardRef(type);
-    return new cpl.CompileIdentifierMetadata(
-        {name: this.sanitizeTokenName(type), moduleUrl, reference: type});
+    return {reference: type};
   }
 
-  private _getTypeMetadata(type: Type<any>, moduleUrl: string, dependencies: any[] = null):
-      cpl.CompileTypeMetadata {
-    const identifier = this._getIdentifierMetadata(type, moduleUrl);
-    return new cpl.CompileTypeMetadata({
-      name: identifier.name,
-      moduleUrl: identifier.moduleUrl,
+  private _getTypeMetadata(type: Type<any>, dependencies: any[] = null): cpl.CompileTypeMetadata {
+    const identifier = this._getIdentifierMetadata(type);
+    return {
       reference: identifier.reference,
       diDeps: this._getDependenciesMetadata(identifier.reference, dependencies),
       lifecycleHooks:
           LIFECYCLE_HOOKS_VALUES.filter(hook => hasLifecycleHook(hook, identifier.reference)),
-    });
+    };
   }
 
-  private _getFactoryMetadata(factory: Function, moduleUrl: string, dependencies: any[] = null):
+  private _getFactoryMetadata(factory: Function, dependencies: any[] = null):
       cpl.CompileFactoryMetadata {
     factory = resolveForwardRef(factory);
-    return new cpl.CompileFactoryMetadata({
-      name: this.sanitizeTokenName(factory),
-      moduleUrl,
-      reference: factory,
-      diDeps: this._getDependenciesMetadata(factory, dependencies)
-    });
+    return {reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies)};
   }
 
   /**
@@ -613,17 +629,21 @@ export class CompileMetadataResolver {
   getPipeMetadata(pipeType: any): cpl.CompilePipeMetadata {
     const pipeMeta = this._pipeCache.get(pipeType);
     if (!pipeMeta) {
-      throw new Error(
-          `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringify(pipeType)}.`);
+      this._reportError(
+          new Error(
+              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringify(pipeType)}.`),
+          pipeType);
     }
     return pipeMeta;
   }
 
   getPipeSummary(pipeType: any): cpl.CompilePipeSummary {
-    const pipeSummary = this._pipeSummaryCache.get(pipeType);
+    const pipeSummary =
+        <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
     if (!pipeSummary) {
-      throw new Error(
-          `Illegal state: getPipeSummary can only be called after loadNgModuleMetadata for a module that imports it. Pipe ${stringify(pipeType)}.`);
+      this._reportError(
+          new Error(`Illegal state: Could not load the summary for pipe ${stringify(pipeType)}.`),
+          pipeType);
     }
     return pipeSummary;
   }
@@ -641,12 +661,12 @@ export class CompileMetadataResolver {
     const pipeAnnotation = this._pipeResolver.resolve(pipeType);
 
     const pipeMeta = new cpl.CompilePipeMetadata({
-      type: this._getTypeMetadata(pipeType, staticTypeModuleUrl(pipeType)),
+      type: this._getTypeMetadata(pipeType),
       name: pipeAnnotation.name,
       pure: pipeAnnotation.pure
     });
     this._pipeCache.set(pipeType, pipeMeta);
-    this._pipeSummaryCache.set(pipeType, pipeMeta.toSummary());
+    this._summaryCache.set(pipeType, pipeMeta.toSummary());
     return pipeMeta;
   }
 
@@ -689,22 +709,23 @@ export class CompileMetadataResolver {
         return null;
       }
 
-      return new cpl.CompileDiDependencyMetadata({
+      return {
         isAttribute,
         isHost,
         isSelf,
         isSkipSelf,
         isOptional,
         token: this._getTokenMetadata(token)
-      });
+      };
 
     });
 
     if (hasUnknownDeps) {
       const depsTokens =
           dependenciesMetadata.map((dep) => dep ? stringify(dep.token) : '?').join(', ');
-      throw new Error(
-          `Can't resolve all parameters for ${stringify(typeOrFunc)}: (${depsTokens}).`);
+      this._reportError(
+          new Error(`Can't resolve all parameters for ${stringify(typeOrFunc)}: (${depsTokens}).`),
+          typeOrFunc);
     }
 
     return dependenciesMetadata;
@@ -714,81 +735,75 @@ export class CompileMetadataResolver {
     token = resolveForwardRef(token);
     let compileToken: cpl.CompileTokenMetadata;
     if (typeof token === 'string') {
-      compileToken = new cpl.CompileTokenMetadata({value: token});
+      compileToken = {value: token};
     } else {
-      compileToken = new cpl.CompileTokenMetadata({
-        identifier: new cpl.CompileIdentifierMetadata({
-          reference: token,
-          name: this.sanitizeTokenName(token),
-          moduleUrl: staticTypeModuleUrl(token)
-        })
-      });
+      compileToken = {identifier: {reference: token}};
     }
     return compileToken;
   }
 
   private _getProvidersMetadata(
       providers: Provider[], targetEntryComponents: cpl.CompileIdentifierMetadata[],
-      debugInfo?: string): Array<cpl.CompileProviderMetadata|cpl.CompileTypeMetadata|any[]> {
-    const compileProviders: Array<cpl.CompileProviderMetadata|cpl.CompileTypeMetadata|any[]> = [];
+      debugInfo?: string, compileProviders: cpl.CompileProviderMetadata[] = [],
+      type?: any): cpl.CompileProviderMetadata[] {
     providers.forEach((provider: any, providerIdx: number) => {
-      provider = resolveForwardRef(provider);
-      if (provider && typeof provider == 'object' && provider.hasOwnProperty('provide')) {
-        provider = new cpl.ProviderMeta(provider.provide, provider);
-      }
-      let compileProvider: cpl.CompileProviderMetadata|cpl.CompileTypeMetadata|any[];
       if (Array.isArray(provider)) {
-        compileProvider = this._getProvidersMetadata(provider, targetEntryComponents, debugInfo);
-      } else if (provider instanceof cpl.ProviderMeta) {
-        const tokenMeta = this._getTokenMetadata(provider.token);
-        if (tokenMeta.reference ===
-            resolveIdentifierToken(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS).reference) {
-          targetEntryComponents.push(...this._getEntryComponentsFromProvider(provider));
-        } else {
-          compileProvider = this.getProviderMetadata(provider);
-        }
-      } else if (isValidType(provider)) {
-        compileProvider = this._getTypeMetadata(provider, staticTypeModuleUrl(provider));
+        this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders);
       } else {
-        const providersInfo =
-            (<string[]>providers.reduce(
-                 (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
-                   if (seenProviderIdx < providerIdx) {
-                     soFar.push(`${stringify(seenProvider)}`);
-                   } else if (seenProviderIdx == providerIdx) {
-                     soFar.push(`?${stringify(seenProvider)}?`);
-                   } else if (seenProviderIdx == providerIdx + 1) {
-                     soFar.push('...');
-                   }
-                   return soFar;
-                 },
-                 []))
-                .join(', ');
-
-        throw new Error(
-            `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`);
-      }
-      if (compileProvider) {
-        compileProviders.push(compileProvider);
+        provider = resolveForwardRef(provider);
+        let providerMeta: cpl.ProviderMeta;
+        if (provider && typeof provider == 'object' && provider.hasOwnProperty('provide')) {
+          providerMeta = new cpl.ProviderMeta(provider.provide, provider);
+        } else if (isValidType(provider)) {
+          providerMeta = new cpl.ProviderMeta(provider, {useClass: provider});
+        } else {
+          const providersInfo =
+              (<string[]>providers.reduce(
+                   (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
+                     if (seenProviderIdx < providerIdx) {
+                       soFar.push(`${stringify(seenProvider)}`);
+                     } else if (seenProviderIdx == providerIdx) {
+                       soFar.push(`?${stringify(seenProvider)}?`);
+                     } else if (seenProviderIdx == providerIdx + 1) {
+                       soFar.push('...');
+                     }
+                     return soFar;
+                   },
+                   []))
+                  .join(', ');
+          this._reportError(
+              new Error(
+                  `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
+              type);
+        }
+        if (providerMeta.token === resolveIdentifier(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) {
+          targetEntryComponents.push(...this._getEntryComponentsFromProvider(providerMeta, type));
+        } else {
+          compileProviders.push(this.getProviderMetadata(providerMeta));
+        }
       }
     });
     return compileProviders;
   }
 
-  private _getEntryComponentsFromProvider(provider: cpl.ProviderMeta):
+  private _getEntryComponentsFromProvider(provider: cpl.ProviderMeta, type?: any):
       cpl.CompileIdentifierMetadata[] {
     const components: cpl.CompileIdentifierMetadata[] = [];
     const collectedIdentifiers: cpl.CompileIdentifierMetadata[] = [];
 
     if (provider.useFactory || provider.useExisting || provider.useClass) {
-      throw new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`);
+      this._reportError(
+          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+      return [];
     }
 
     if (!provider.multi) {
-      throw new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`);
+      this._reportError(
+          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`), type);
+      return [];
     }
 
-    convertToCompileValue(provider.useValue, collectedIdentifiers);
+    extractIdentifiers(provider.useValue, collectedIdentifiers);
     collectedIdentifiers.forEach((identifier) => {
       if (this._directiveResolver.isDirective(identifier.reference)) {
         components.push(identifier);
@@ -801,26 +816,29 @@ export class CompileMetadataResolver {
     let compileDeps: cpl.CompileDiDependencyMetadata[];
     let compileTypeMetadata: cpl.CompileTypeMetadata = null;
     let compileFactoryMetadata: cpl.CompileFactoryMetadata = null;
+    let token: cpl.CompileTokenMetadata = this._getTokenMetadata(provider.token);
 
     if (provider.useClass) {
-      compileTypeMetadata = this._getTypeMetadata(
-          provider.useClass, staticTypeModuleUrl(provider.useClass), provider.dependencies);
+      compileTypeMetadata = this._getTypeMetadata(provider.useClass, provider.dependencies);
       compileDeps = compileTypeMetadata.diDeps;
+      if (provider.token === provider.useClass) {
+        // use the compileTypeMetadata as it contains information about lifecycleHooks...
+        token = {identifier: compileTypeMetadata};
+      }
     } else if (provider.useFactory) {
-      compileFactoryMetadata = this._getFactoryMetadata(
-          provider.useFactory, staticTypeModuleUrl(provider.useFactory), provider.dependencies);
+      compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies);
       compileDeps = compileFactoryMetadata.diDeps;
     }
 
-    return new cpl.CompileProviderMetadata({
-      token: this._getTokenMetadata(provider.token),
+    return {
+      token: token,
       useClass: compileTypeMetadata,
-      useValue: convertToCompileValue(provider.useValue, []),
+      useValue: provider.useValue,
       useFactory: compileFactoryMetadata,
       useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : null,
       deps: compileDeps,
       multi: provider.multi
-    });
+    };
   }
 
   private _getQueriesMetadata(
@@ -848,52 +866,32 @@ export class CompileMetadataResolver {
           this._queryVarBindings(q.selector).map(varName => this._getTokenMetadata(varName));
     } else {
       if (!q.selector) {
-        throw new Error(
-            `Can't construct a query for the property "${propertyName}" of "${stringify(typeOrFunc)}" since the query selector wasn't defined.`);
+        this._reportError(
+            new Error(
+                `Can't construct a query for the property "${propertyName}" of "${stringify(typeOrFunc)}" since the query selector wasn't defined.`),
+            typeOrFunc);
       }
       selectors = [this._getTokenMetadata(q.selector)];
     }
 
-    return new cpl.CompileQueryMetadata({
+    return {
       selectors,
       first: q.first,
       descendants: q.descendants, propertyName,
       read: q.read ? this._getTokenMetadata(q.read) : null
-    });
+    };
   }
-}
 
-function getTransitiveExportedModules(
-    modules: cpl.CompileNgModuleDirectiveSummary[],
-    targetModules: cpl.CompileNgModuleDirectiveSummary[] = [],
-    visitedModules = new Set<Type<any>>()): cpl.CompileNgModuleDirectiveSummary[] {
-  modules.forEach((ngModule) => {
-    if (!visitedModules.has(ngModule.type.reference)) {
-      visitedModules.add(ngModule.type.reference);
-      getTransitiveExportedModules(ngModule.exportedModules, targetModules, visitedModules);
-      // Add after recursing so imported/exported modules are before the module itself.
-      // This is important for overwriting providers of imported modules!
-      targetModules.push(ngModule);
+  private _reportError(error: any, type?: any, otherType?: any) {
+    if (this._errorCollector) {
+      this._errorCollector(error, type);
+      if (otherType) {
+        this._errorCollector(error, otherType);
+      }
+    } else {
+      throw error;
     }
-  });
-  return targetModules;
-}
-
-function getTransitiveImportedModules(
-    modules: cpl.CompileNgModuleInjectorSummary[],
-    targetModules: cpl.CompileNgModuleInjectorSummary[] = [],
-    visitedModules = new Set<Type<any>>()): cpl.CompileNgModuleInjectorSummary[] {
-  modules.forEach((ngModule) => {
-    if (!visitedModules.has(ngModule.type.reference)) {
-      visitedModules.add(ngModule.type.reference);
-      const nestedModules = ngModule.importedModules.concat(ngModule.exportedModules);
-      getTransitiveImportedModules(nestedModules, targetModules, visitedModules);
-      // Add after recursing so imported/exported modules are before the module itself.
-      // This is important for overwriting providers of imported modules!
-      targetModules.push(ngModule);
-    }
-  });
-  return targetModules;
+  }
 }
 
 function flattenArray(tree: any[], out: Array<any> = []): Array<any> {
@@ -922,17 +920,13 @@ function flattenAndDedupeArray(tree: any[]): Array<any> {
 }
 
 function isValidType(value: any): boolean {
-  return isStaticSymbol(value) || (value instanceof Type);
+  return (value instanceof StaticSymbol) || (value instanceof Type);
 }
 
-function staticTypeModuleUrl(value: any): string {
-  return isStaticSymbol(value) ? value.filePath : null;
-}
-
-function componentModuleUrl(
+export function componentModuleUrl(
     reflector: ReflectorReader, type: Type<any>, cmpMetadata: Component): string {
-  if (isStaticSymbol(type)) {
-    return staticTypeModuleUrl(type);
+  if (type instanceof StaticSymbol) {
+    return type.filePath;
   }
 
   const moduleId = cmpMetadata.moduleId;
@@ -949,21 +943,12 @@ function componentModuleUrl(
   return reflector.importUri(type);
 }
 
-function convertToCompileValue(
-    value: any, targetIdentifiers: cpl.CompileIdentifierMetadata[]): any {
-  return visitValue(value, new _CompileValueConverter(), targetIdentifiers);
+function extractIdentifiers(value: any, targetIdentifiers: cpl.CompileIdentifierMetadata[]) {
+  visitValue(value, new _CompileValueConverter(), targetIdentifiers);
 }
 
 class _CompileValueConverter extends ValueTransformer {
   visitOther(value: any, targetIdentifiers: cpl.CompileIdentifierMetadata[]): any {
-    let identifier: cpl.CompileIdentifierMetadata;
-    if (isStaticSymbol(value)) {
-      identifier = new cpl.CompileIdentifierMetadata(
-          {name: value.name, moduleUrl: value.filePath, reference: value});
-    } else {
-      identifier = new cpl.CompileIdentifierMetadata({reference: value});
-    }
-    targetIdentifiers.push(identifier);
-    return identifier;
+    targetIdentifiers.push({reference: value});
   }
 }

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

@@ -8,10 +8,10 @@
 
 import {Injectable} from '@angular/core';
 
-import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata} from './compile_metadata';
+import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName, tokenName, tokenReference} from './compile_metadata';
 import {createDiTokenExpression} from './compiler_util/identifier_util';
 import {isPresent} from './facade/lang';
-import {Identifiers, resolveIdentifier, resolveIdentifierToken} from './identifiers';
+import {Identifiers, createIdentifier, createIdentifierToken, resolveIdentifier} from './identifiers';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {convertValueToOutputAst} from './output/value_util';
@@ -35,9 +35,10 @@ export class NgModuleCompileResult {
 export class NgModuleCompiler {
   compile(ngModuleMeta: CompileNgModuleMetadata, extraProviders: CompileProviderMetadata[]):
       NgModuleCompileResult {
-    const sourceFileName = isPresent(ngModuleMeta.type.moduleUrl) ?
-        `in NgModule ${ngModuleMeta.type.name} in ${ngModuleMeta.type.moduleUrl}` :
-        `in NgModule ${ngModuleMeta.type.name}`;
+    const moduleUrl = identifierModuleUrl(ngModuleMeta.type);
+    const sourceFileName = isPresent(moduleUrl) ?
+        `in NgModule ${identifierName(ngModuleMeta.type)} in ${moduleUrl}` :
+        `in NgModule ${identifierName(ngModuleMeta.type)}`;
     const sourceFile = new ParseSourceFile('', sourceFileName);
     const sourceSpan = new ParseSourceSpan(
         new ParseLocation(sourceFile, null, null, null),
@@ -46,8 +47,9 @@ export class NgModuleCompiler {
     const bootstrapComponentFactories: CompileIdentifierMetadata[] = [];
     const entryComponentFactories =
         ngModuleMeta.transitiveModule.entryComponents.map((entryComponent) => {
-          const id = new CompileIdentifierMetadata({name: entryComponent.name});
-          if (ngModuleMeta.bootstrapComponents.indexOf(entryComponent) > -1) {
+          const id: CompileIdentifierMetadata = {reference: null};
+          if (ngModuleMeta.bootstrapComponents.some(
+                  (id) => id.reference === entryComponent.reference)) {
             bootstrapComponentFactories.push(id);
           }
           deps.push(new ComponentFactoryDependency(entryComponent, id));
@@ -59,21 +61,21 @@ export class NgModuleCompiler {
     const providerParser = new NgModuleProviderAnalyzer(ngModuleMeta, extraProviders, sourceSpan);
     providerParser.parse().forEach((provider) => builder.addProvider(provider));
     const injectorClass = builder.build();
-    const ngModuleFactoryVar = `${ngModuleMeta.type.name}NgFactory`;
+    const ngModuleFactoryVar = `${identifierName(ngModuleMeta.type)}NgFactory`;
     const ngModuleFactoryStmt =
         o.variable(ngModuleFactoryVar)
-            .set(o.importExpr(resolveIdentifier(Identifiers.NgModuleFactory))
+            .set(o.importExpr(createIdentifier(Identifiers.NgModuleFactory))
                      .instantiate(
                          [o.variable(injectorClass.name), o.importExpr(ngModuleMeta.type)],
                          o.importType(
-                             resolveIdentifier(Identifiers.NgModuleFactory),
+                             createIdentifier(Identifiers.NgModuleFactory),
                              [o.importType(ngModuleMeta.type)], [o.TypeModifier.Const])))
             .toDeclStmt(null, [o.StmtModifier.Final]);
 
     const stmts: o.Statement[] = [injectorClass, ngModuleFactoryStmt];
     if (ngModuleMeta.id) {
       const registerFactoryStmt =
-          o.importExpr(resolveIdentifier(Identifiers.RegisterModuleFactoryFn))
+          o.importExpr(createIdentifier(Identifiers.RegisterModuleFactoryFn))
               .callFn([o.literal(ngModuleMeta.id), o.variable(ngModuleFactoryVar)])
               .toStmt();
       stmts.push(registerFactoryStmt);
@@ -102,7 +104,7 @@ class _InjectorBuilder implements ClassBuilder {
   addProvider(resolvedProvider: ProviderAst) {
     const providerValueExpressions =
         resolvedProvider.providers.map((provider) => this._getProviderValue(provider));
-    const propName = `_${resolvedProvider.token.name}_${this._instances.size}`;
+    const propName = `_${tokenName(resolvedProvider.token)}_${this._instances.size}`;
     const instance = this._createProviderProperty(
         propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider,
         resolvedProvider.eager);
@@ -110,12 +112,12 @@ class _InjectorBuilder implements ClassBuilder {
       this._destroyStmts.push(instance.callMethod('ngOnDestroy', []).toStmt());
     }
     this._tokens.push(resolvedProvider.token);
-    this._instances.set(resolvedProvider.token.reference, instance);
+    this._instances.set(tokenReference(resolvedProvider.token), instance);
   }
 
   build(): o.ClassStmt {
     const getMethodStmts: o.Statement[] = this._tokens.map((token) => {
-      const providerExpr = this._instances.get(token.reference);
+      const providerExpr = this._instances.get(tokenReference(token));
       return new o.IfStmt(
           InjectMethodVars.token.identical(createDiTokenExpression(token)),
           [new o.ReturnStatement(providerExpr)]);
@@ -143,13 +145,13 @@ class _InjectorBuilder implements ClassBuilder {
       o.literalArr(this._bootstrapComponentFactories.map(
           (componentFactory) => o.importExpr(componentFactory)))
     ];
-    const injClassName = `${this._ngModuleMeta.type.name}Injector`;
+    const injClassName = `${identifierName(this._ngModuleMeta.type)}Injector`;
     return createClassStmt({
       name: injClassName,
       ctorParams: [new o.FnParam(
-          InjectorProps.parent.name, o.importType(resolveIdentifier(Identifiers.Injector)))],
+          InjectorProps.parent.name, o.importType(createIdentifier(Identifiers.Injector)))],
       parent: o.importExpr(
-          resolveIdentifier(Identifiers.NgModuleInjector), [o.importType(this._ngModuleMeta.type)]),
+          createIdentifier(Identifiers.NgModuleInjector), [o.importType(this._ngModuleMeta.type)]),
       parentArgs: parentArgs,
       builders: [{methods}, this]
     });
@@ -158,7 +160,7 @@ class _InjectorBuilder implements ClassBuilder {
   private _getProviderValue(provider: CompileProviderMetadata): o.Expression {
     let result: o.Expression;
     if (isPresent(provider.useExisting)) {
-      result = this._getDependency(new CompileDiDependencyMetadata({token: provider.useExisting}));
+      result = this._getDependency({token: provider.useExisting});
     } else if (isPresent(provider.useFactory)) {
       const deps = provider.deps || provider.useFactory.diDeps;
       const depsExpr = deps.map((dep) => this._getDependency(dep));
@@ -215,13 +217,12 @@ class _InjectorBuilder implements ClassBuilder {
     }
     if (!dep.isSkipSelf) {
       if (dep.token &&
-          (dep.token.reference === resolveIdentifierToken(Identifiers.Injector).reference ||
-           dep.token.reference ===
-               resolveIdentifierToken(Identifiers.ComponentFactoryResolver).reference)) {
+          (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector) ||
+           tokenReference(dep.token) === resolveIdentifier(Identifiers.ComponentFactoryResolver))) {
         result = o.THIS_EXPR;
       }
       if (!result) {
-        result = this._instances.get(dep.token.reference);
+        result = this._instances.get(tokenReference(dep.token));
       }
     }
     if (!result) {

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

@@ -8,6 +8,7 @@
 
 import {Injectable, NgModule, Type} from '@angular/core';
 
+import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
 import {ReflectorReader, reflector} from './private_import_core';
 
@@ -25,7 +26,8 @@ export class NgModuleResolver {
   isNgModule(type: any) { return this._reflector.annotations(type).some(_isNgModuleMetadata); }
 
   resolve(type: Type<any>, throwIfNotFound = true): NgModule {
-    const ngModuleMeta: NgModule = this._reflector.annotations(type).find(_isNgModuleMetadata);
+    const ngModuleMeta: NgModule =
+        ListWrapper.findLast(this._reflector.annotations(type), _isNgModuleMetadata);
 
     if (isPresent(ngModuleMeta)) {
       return ngModuleMeta;

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

@@ -367,8 +367,8 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     ctx.print(`{`, useNewLine);
     ctx.incIndent();
     this.visitAllObjects(entry => {
-      ctx.print(`${escapeIdentifier(entry[0], this._escapeDollarInStrings, false)}: `);
-      entry[1].visitExpression(this, ctx);
+      ctx.print(`${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}: `);
+      entry.value.visitExpression(this, ctx);
     }, ast.entries, ctx, ',', useNewLine);
     ctx.decIndent();
     ctx.print(`}`, useNewLine);

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

@@ -7,6 +7,7 @@
  */
 
 
+import {identifierModuleUrl, identifierName} from '../compile_metadata';
 import {isBlank, isPresent} from '../facade/lang';
 
 import {EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
@@ -38,18 +39,21 @@ class JsEmitterVisitor extends AbstractJsEmitterVisitor {
   constructor(private _moduleUrl: string) { super(); }
 
   visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    if (isBlank(ast.value.name)) {
+    const name = identifierName(ast.value);
+    const moduleUrl = identifierModuleUrl(ast.value);
+    if (isBlank(name)) {
+      console.error('>>>', ast.value);
       throw new Error(`Internal error: unknown identifier ${ast.value}`);
     }
-    if (isPresent(ast.value.moduleUrl) && ast.value.moduleUrl != this._moduleUrl) {
-      let prefix = this.importsWithPrefixes.get(ast.value.moduleUrl);
+    if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {
+      let prefix = this.importsWithPrefixes.get(moduleUrl);
       if (isBlank(prefix)) {
         prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(ast.value.moduleUrl, prefix);
+        this.importsWithPrefixes.set(moduleUrl, prefix);
       }
       ctx.print(`${prefix}.`);
     }
-    ctx.print(ast.value.name);
+    ctx.print(name);
     return null;
   }
   visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {

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

@@ -43,14 +43,14 @@ export class BuiltinType extends Type {
   }
 }
 
-export class ExternalType extends Type {
+export class ExpressionType extends Type {
   constructor(
-      public value: CompileIdentifierMetadata, public typeParams: Type[] = null,
+      public value: Expression, public typeParams: Type[] = null,
       modifiers: TypeModifier[] = null) {
     super(modifiers);
   }
   visitType(visitor: TypeVisitor, context: any): any {
-    return visitor.visitExternalType(this, context);
+    return visitor.visitExpressionType(this, context);
   }
 }
 
@@ -78,7 +78,7 @@ export var NULL_TYPE = new BuiltinType(BuiltinTypeName.Null);
 
 export interface TypeVisitor {
   visitBuiltintType(type: BuiltinType, context: any): any;
-  visitExternalType(type: ExternalType, context: any): any;
+  visitExpressionType(type: ExpressionType, context: any): any;
   visitArrayType(type: ArrayType, context: any): any;
   visitMapType(type: MapType, context: any): any;
 }
@@ -413,10 +413,13 @@ export class LiteralArrayExpr extends Expression {
   }
 }
 
+export class LiteralMapEntry {
+  constructor(public key: string, public value: Expression, public quoted: boolean = false) {}
+}
 
 export class LiteralMapExpr extends Expression {
   public valueType: Type = null;
-  constructor(public entries: [string, Expression][], type: MapType = null) {
+  constructor(public entries: LiteralMapEntry[], type: MapType = null) {
     super(type);
     if (isPresent(type)) {
       this.valueType = type.valueType;
@@ -677,7 +680,8 @@ export class ExpressionTransformer implements StatementVisitor, ExpressionVisito
 
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
     const entries = ast.entries.map(
-        (entry): [string, Expression] => [entry[0], entry[1].visitExpression(this, context), ]);
+        (entry): LiteralMapEntry => new LiteralMapEntry(
+            entry.key, entry.value.visitExpression(this, context), entry.quoted));
     return new LiteralMapExpr(entries);
   }
   visitAllExpressions(exprs: Expression[], context: any): Expression[] {
@@ -791,7 +795,7 @@ export class RecursiveExpressionVisitor implements StatementVisitor, ExpressionV
     return ast;
   }
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any {
-    ast.entries.forEach((entry) => (<Expression>entry[1]).visitExpression(this, context));
+    ast.entries.forEach((entry) => entry.value.visitExpression(this, context));
     return ast;
   }
   visitAllExpressions(exprs: Expression[], context: any): void {
@@ -876,8 +880,14 @@ export function importExpr(id: CompileIdentifierMetadata, typeParams: Type[] = n
 
 export function importType(
     id: CompileIdentifierMetadata, typeParams: Type[] = null,
-    typeModifiers: TypeModifier[] = null): ExternalType {
-  return isPresent(id) ? new ExternalType(id, typeParams, typeModifiers) : null;
+    typeModifiers: TypeModifier[] = null): ExpressionType {
+  return isPresent(id) ? expressionType(importExpr(id), typeParams, typeModifiers) : null;
+}
+
+export function expressionType(
+    expr: Expression, typeParams: Type[] = null,
+    typeModifiers: TypeModifier[] = null): ExpressionType {
+  return isPresent(expr) ? new ExpressionType(expr, typeParams, typeModifiers) : null;
 }
 
 export function literalArr(values: Expression[], type: Type = null): LiteralArrayExpr {
@@ -885,7 +895,7 @@ export function literalArr(values: Expression[], type: Type = null): LiteralArra
 }
 
 export function literalMap(values: [string, Expression][], type: MapType = null): LiteralMapExpr {
-  return new LiteralMapExpr(values, type);
+  return new LiteralMapExpr(values.map(entry => new LiteralMapEntry(entry[0], entry[1])), type);
 }
 
 export function not(expr: Expression): NotExpr {

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

@@ -301,8 +301,7 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
   visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: _ExecutionContext): any {
     const result = {};
     ast.entries.forEach(
-        (entry) => (result as any)[<string>entry[0]] =
-            (<o.Expression>entry[1]).visitExpression(this, ctx));
+        (entry) => (result as any)[entry.key] = entry.value.visitExpression(this, ctx));
     return result;
   }
 

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

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {identifierName} from '../compile_metadata';
 import {isPresent} from '../facade/lang';
-import {sanitizeIdentifier} from '../util';
 
 import {EmitterVisitorContext} from './abstract_emitter';
 import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
@@ -52,8 +52,8 @@ class JitEmitterVisitor extends AbstractJsEmitterVisitor {
     if (id === -1) {
       id = this._evalArgValues.length;
       this._evalArgValues.push(value);
-      const name = isPresent(ast.value.name) ? sanitizeIdentifier(ast.value.name) : 'val';
-      this._evalArgNames.push(sanitizeIdentifier(`jit_${name}${id}`));
+      const name = identifierName(ast.value) || 'val';
+      this._evalArgNames.push(`jit_${name}${id}`);
     }
     ctx.print(this._evalArgNames[id]);
     return null;

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

@@ -7,7 +7,7 @@
  */
 
 
-import {CompileIdentifierMetadata} from '../compile_metadata';
+import {CompileIdentifierMetadata, identifierModuleUrl, identifierName} from '../compile_metadata';
 import {isBlank, isPresent} from '../facade/lang';
 
 import {AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
@@ -271,8 +271,13 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
     return null;
   }
 
-  visitExternalType(ast: o.ExternalType, ctx: EmitterVisitorContext): any {
-    this._visitIdentifier(ast.value, ast.typeParams, ctx);
+  visitExpressionType(ast: o.ExpressionType, ctx: EmitterVisitorContext): any {
+    ast.value.visitExpression(this, ctx);
+    if (isPresent(ast.typeParams) && ast.typeParams.length > 0) {
+      ctx.print(`<`);
+      this.visitAllObjects(type => type.visitType(this, ctx), ast.typeParams, ctx, ',');
+      ctx.print(`>`);
+    }
     return null;
   }
 
@@ -317,14 +322,16 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
 
   private _visitIdentifier(
       value: CompileIdentifierMetadata, typeParams: o.Type[], ctx: EmitterVisitorContext): void {
-    if (isBlank(value.name)) {
+    const name = identifierName(value);
+    const moduleUrl = identifierModuleUrl(value);
+    if (isBlank(name)) {
       throw new Error(`Internal error: unknown identifier ${value}`);
     }
-    if (isPresent(value.moduleUrl) && value.moduleUrl != this._moduleUrl) {
-      let prefix = this.importsWithPrefixes.get(value.moduleUrl);
+    if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {
+      let prefix = this.importsWithPrefixes.get(moduleUrl);
       if (isBlank(prefix)) {
         prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(value.moduleUrl, prefix);
+        this.importsWithPrefixes.set(moduleUrl, prefix);
       }
       ctx.print(`${prefix}.`);
     }
@@ -333,7 +340,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
       ctx.print('.');
       ctx.print(value.reference.members.join('.'));
     } else {
-      ctx.print(value.name);
+      ctx.print(name);
     }
     if (isPresent(typeParams) && typeParams.length > 0) {
       ctx.print(`<`);

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

@@ -12,6 +12,8 @@ import {ValueTransformer, visitValue} from '../util';
 
 import * as o from './output_ast';
 
+export const QUOTED_KEYS = '$quoted$';
+
 export function convertValueToOutputAst(value: any, type: o.Type = null): o.Expression {
   return visitValue(value, new _ValueOutputAstTransformer(), type);
 }
@@ -22,20 +24,22 @@ class _ValueOutputAstTransformer implements ValueTransformer {
   }
 
   visitStringMap(map: {[key: string]: any}, type: o.MapType): o.Expression {
-    const entries: [string, o.Expression][] = [];
-    Object.keys(map).forEach(key => { entries.push([key, visitValue(map[key], this, null)]); });
-    return o.literalMap(entries, type);
+    const entries: o.LiteralMapEntry[] = [];
+    const quotedSet = new Set<string>(map && map[QUOTED_KEYS]);
+    Object.keys(map).forEach(key => {
+      entries.push(
+          new o.LiteralMapEntry(key, visitValue(map[key], this, null), quotedSet.has(key)));
+    });
+    return new o.LiteralMapExpr(entries, type);
   }
 
   visitPrimitive(value: any, type: o.Type): o.Expression { return o.literal(value, type); }
 
   visitOther(value: any, type: o.Type): o.Expression {
-    if (value instanceof CompileIdentifierMetadata) {
-      return o.importExpr(value);
-    } else if (value instanceof o.Expression) {
+    if (value instanceof o.Expression) {
       return value;
     } else {
-      throw new Error(`Illegal state: Don't now how to compile value ${value}`);
+      return o.importExpr({reference: value});
     }
   }
 }

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

@@ -5,6 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import * as chars from './chars';
 import {isPresent} from './facade/lang';
 
 export class ParseLocation {
@@ -15,6 +16,38 @@ export class ParseLocation {
   toString(): string {
     return isPresent(this.offset) ? `${this.file.url}@${this.line}:${this.col}` : this.file.url;
   }
+
+  moveBy(delta: number): ParseLocation {
+    const source = this.file.content;
+    const len = source.length;
+    let offset = this.offset;
+    let line = this.line;
+    let col = this.col;
+    while (offset > 0 && delta < 0) {
+      offset--;
+      delta++;
+      const ch = source.charCodeAt(offset);
+      if (ch == chars.$LF) {
+        line--;
+        const priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode(chars.$LF));
+        col = priorLine > 0 ? offset - priorLine : offset;
+      } else {
+        col--;
+      }
+    }
+    while (offset < len && delta > 0) {
+      const ch = source.charCodeAt(offset);
+      offset++;
+      delta--;
+      if (ch == chars.$LF) {
+        line++;
+        col = 0;
+      } else {
+        col++;
+      }
+    }
+    return new ParseLocation(this.file, offset, line, col);
+  }
 }
 
 export class ParseSourceFile {

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

@@ -8,6 +8,7 @@
 
 import {Injectable, Pipe, Type, resolveForwardRef} from '@angular/core';
 
+import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
 import {ReflectorReader, reflector} from './private_import_core';
 
@@ -37,7 +38,7 @@ export class PipeResolver {
   resolve(type: Type<any>, throwIfNotFound = true): Pipe {
     const metas = this._reflector.annotations(resolveForwardRef(type));
     if (isPresent(metas)) {
-      const annotation = metas.find(_isPipeMetadata);
+      const annotation = ListWrapper.findLast(metas, _isPipeMetadata);
       if (isPresent(annotation)) {
         return annotation;
       }

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

@@ -7,9 +7,9 @@
  */
 
 
-import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata} from './compile_metadata';
+import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata, tokenName, tokenReference} from './compile_metadata';
 import {isBlank, isPresent} from './facade/lang';
-import {Identifiers, resolveIdentifierToken} from './identifiers';
+import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
 import {ParseError, ParseSourceSpan} from './parse_util';
 import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, ReferenceAst} from './template_parser/template_ast';
 
@@ -31,9 +31,9 @@ export class ProviderViewContext {
   constructor(public component: CompileDirectiveMetadata, public sourceSpan: ParseSourceSpan) {
     this.viewQueries = _getViewQueries(component);
     this.viewProviders = new Map<any, boolean>();
-    _normalizeProviders(component.viewProviders, sourceSpan, this.errors).forEach((provider) => {
-      if (isBlank(this.viewProviders.get(provider.token.reference))) {
-        this.viewProviders.set(provider.token.reference, true);
+    component.viewProviders.forEach((provider) => {
+      if (isBlank(this.viewProviders.get(tokenReference(provider.token)))) {
+        this.viewProviders.set(tokenReference(provider.token), true);
       }
     });
   }
@@ -62,17 +62,14 @@ export class ProviderElementContext {
     Array.from(this._allProviders.values()).forEach((provider) => {
       this._addQueryReadsTo(provider.token, queriedTokens);
     });
-    refs.forEach((refAst) => {
-      this._addQueryReadsTo(new CompileTokenMetadata({value: refAst.name}), queriedTokens);
-    });
-    if (isPresent(
-            queriedTokens.get(resolveIdentifierToken(Identifiers.ViewContainerRef).reference))) {
+    refs.forEach((refAst) => { this._addQueryReadsTo({value: refAst.name}, queriedTokens); });
+    if (isPresent(queriedTokens.get(resolveIdentifier(Identifiers.ViewContainerRef)))) {
       this._hasViewContainer = true;
     }
 
     // create the providers that we know are eager first
     Array.from(this._allProviders.values()).forEach((provider) => {
-      const eager = provider.eager || isPresent(queriedTokens.get(provider.token.reference));
+      const eager = provider.eager || isPresent(queriedTokens.get(tokenReference(provider.token)));
       if (eager) {
         this._getOrCreateLocalProvider(provider.providerType, provider.token, true);
       }
@@ -104,8 +101,8 @@ export class ProviderElementContext {
   private _addQueryReadsTo(token: CompileTokenMetadata, queryReadTokens: Map<any, boolean>) {
     this._getQueriesFor(token).forEach((query) => {
       const queryReadToken = query.read || token;
-      if (isBlank(queryReadTokens.get(queryReadToken.reference))) {
-        queryReadTokens.set(queryReadToken.reference, true);
+      if (isBlank(queryReadTokens.get(tokenReference(queryReadToken)))) {
+        queryReadTokens.set(tokenReference(queryReadToken), true);
       }
     });
   }
@@ -116,7 +113,7 @@ export class ProviderElementContext {
     let distance = 0;
     let queries: CompileQueryMetadata[];
     while (currentEl !== null) {
-      queries = currentEl._contentQueries.get(token.reference);
+      queries = currentEl._contentQueries.get(tokenReference(token));
       if (isPresent(queries)) {
         result.push(...queries.filter((query) => query.descendants || distance <= 1));
       }
@@ -125,7 +122,7 @@ export class ProviderElementContext {
       }
       currentEl = currentEl._parent;
     }
-    queries = this.viewContext.viewQueries.get(token.reference);
+    queries = this.viewContext.viewQueries.get(tokenReference(token));
     if (isPresent(queries)) {
       result.push(...queries);
     }
@@ -136,7 +133,7 @@ export class ProviderElementContext {
   private _getOrCreateLocalProvider(
       requestingProviderType: ProviderAstType, token: CompileTokenMetadata,
       eager: boolean): ProviderAst {
-    const resolvedProvider = this._allProviders.get(token.reference);
+    const resolvedProvider = this._allProviders.get(tokenReference(token));
     if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||
                                requestingProviderType === ProviderAstType.PublicService) &&
                               resolvedProvider.providerType === ProviderAstType.PrivateService) ||
@@ -145,24 +142,23 @@ export class ProviderElementContext {
          resolvedProvider.providerType === ProviderAstType.Builtin)) {
       return null;
     }
-    let transformedProviderAst = this._transformedProviders.get(token.reference);
+    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
     if (isPresent(transformedProviderAst)) {
       return transformedProviderAst;
     }
-    if (isPresent(this._seenProviders.get(token.reference))) {
+    if (isPresent(this._seenProviders.get(tokenReference(token)))) {
       this.viewContext.errors.push(new ProviderError(
-          `Cannot instantiate cyclic dependency! ${token.name}`, this._sourceSpan));
+          `Cannot instantiate cyclic dependency! ${tokenName(token)}`, this._sourceSpan));
       return null;
     }
-    this._seenProviders.set(token.reference, true);
+    this._seenProviders.set(tokenReference(token), true);
     const transformedProviders = resolvedProvider.providers.map((provider) => {
       let transformedUseValue = provider.useValue;
       let transformedUseExisting = provider.useExisting;
       let transformedDeps: CompileDiDependencyMetadata[];
       if (isPresent(provider.useExisting)) {
         const existingDiDep = this._getDependency(
-            resolvedProvider.providerType,
-            new CompileDiDependencyMetadata({token: provider.useExisting}), eager);
+            resolvedProvider.providerType, {token: provider.useExisting}, eager);
         if (isPresent(existingDiDep.token)) {
           transformedUseExisting = existingDiDep.token;
         } else {
@@ -186,7 +182,7 @@ export class ProviderElementContext {
     });
     transformedProviderAst =
         _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});
-    this._transformedProviders.set(token.reference, transformedProviderAst);
+    this._transformedProviders.set(tokenReference(token), transformedProviderAst);
     return transformedProviderAst;
   }
 
@@ -195,28 +191,25 @@ export class ProviderElementContext {
       eager: boolean = null): CompileDiDependencyMetadata {
     if (dep.isAttribute) {
       const attrValue = this._attrs[dep.token.value];
-      return new CompileDiDependencyMetadata(
-          {isValue: true, value: attrValue == null ? null : attrValue});
+      return {isValue: true, value: attrValue == null ? null : attrValue};
     }
 
     if (isPresent(dep.token)) {
       // access builtints
       if ((requestingProviderType === ProviderAstType.Directive ||
            requestingProviderType === ProviderAstType.Component)) {
-        if (dep.token.reference === resolveIdentifierToken(Identifiers.Renderer).reference ||
-            dep.token.reference === resolveIdentifierToken(Identifiers.ElementRef).reference ||
-            dep.token.reference ===
-                resolveIdentifierToken(Identifiers.ChangeDetectorRef).reference ||
-            dep.token.reference === resolveIdentifierToken(Identifiers.TemplateRef).reference) {
+        if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Renderer) ||
+            tokenReference(dep.token) === resolveIdentifier(Identifiers.ElementRef) ||
+            tokenReference(dep.token) === resolveIdentifier(Identifiers.ChangeDetectorRef) ||
+            tokenReference(dep.token) === resolveIdentifier(Identifiers.TemplateRef)) {
           return dep;
         }
-        if (dep.token.reference ===
-            resolveIdentifierToken(Identifiers.ViewContainerRef).reference) {
+        if (tokenReference(dep.token) === resolveIdentifier(Identifiers.ViewContainerRef)) {
           this._hasViewContainer = true;
         }
       }
       // access the injector
-      if (dep.token.reference === resolveIdentifierToken(Identifiers.Injector).reference) {
+      if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector)) {
         return dep;
       }
       // access providers
@@ -238,7 +231,7 @@ export class ProviderElementContext {
     }
     if (dep.isSelf) {
       if (!result && dep.isOptional) {
-        result = new CompileDiDependencyMetadata({isValue: true, value: null});
+        result = {isValue: true, value: null};
       }
     } else {
       // check parent elements
@@ -252,20 +245,18 @@ export class ProviderElementContext {
       }
       // check @Host restriction
       if (!result) {
-        if (!dep.isHost || this.viewContext.component.type.isHost ||
-            this.viewContext.component.type.reference === dep.token.reference ||
-            isPresent(this.viewContext.viewProviders.get(dep.token.reference))) {
+        if (!dep.isHost || this.viewContext.component.isHost ||
+            this.viewContext.component.type.reference === tokenReference(dep.token) ||
+            isPresent(this.viewContext.viewProviders.get(tokenReference(dep.token)))) {
           result = dep;
         } else {
-          result = dep.isOptional ?
-              result = new CompileDiDependencyMetadata({isValue: true, value: null}) :
-              null;
+          result = dep.isOptional ? result = {isValue: true, value: null} : null;
         }
       }
     }
     if (!result) {
       this.viewContext.errors.push(
-          new ProviderError(`No provider for ${dep.token.name}`, this._sourceSpan));
+          new ProviderError(`No provider for ${tokenName(dep.token)}`, this._sourceSpan));
     }
     return result;
   }
@@ -282,17 +273,14 @@ export class NgModuleProviderAnalyzer {
       ngModule: CompileNgModuleMetadata, extraProviders: CompileProviderMetadata[],
       sourceSpan: ParseSourceSpan) {
     this._allProviders = new Map<any, ProviderAst>();
-    const ngModuleTypes = ngModule.transitiveModule.modules.map((moduleMeta) => moduleMeta.type);
-    ngModuleTypes.forEach((ngModuleType: CompileTypeMetadata) => {
-      const ngModuleProvider = new CompileProviderMetadata(
-          {token: new CompileTokenMetadata({identifier: ngModuleType}), useClass: ngModuleType});
+    ngModule.transitiveModule.modules.forEach((ngModuleType: CompileTypeMetadata) => {
+      const ngModuleProvider = {token: {identifier: ngModuleType}, useClass: ngModuleType};
       _resolveProviders(
           [ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, this._errors,
           this._allProviders);
     });
     _resolveProviders(
-        _normalizeProviders(
-            ngModule.transitiveModule.providers.concat(extraProviders), sourceSpan, this._errors),
+        ngModule.transitiveModule.providers.map(entry => entry.provider).concat(extraProviders),
         ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders);
   }
 
@@ -308,28 +296,28 @@ export class NgModuleProviderAnalyzer {
   }
 
   private _getOrCreateLocalProvider(token: CompileTokenMetadata, eager: boolean): ProviderAst {
-    const resolvedProvider = this._allProviders.get(token.reference);
+    const resolvedProvider = this._allProviders.get(tokenReference(token));
     if (!resolvedProvider) {
       return null;
     }
-    let transformedProviderAst = this._transformedProviders.get(token.reference);
+    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
     if (isPresent(transformedProviderAst)) {
       return transformedProviderAst;
     }
-    if (isPresent(this._seenProviders.get(token.reference))) {
+    if (isPresent(this._seenProviders.get(tokenReference(token)))) {
       this._errors.push(new ProviderError(
-          `Cannot instantiate cyclic dependency! ${token.name}`, resolvedProvider.sourceSpan));
+          `Cannot instantiate cyclic dependency! ${tokenName(token)}`,
+          resolvedProvider.sourceSpan));
       return null;
     }
-    this._seenProviders.set(token.reference, true);
+    this._seenProviders.set(tokenReference(token), true);
     const transformedProviders = resolvedProvider.providers.map((provider) => {
       let transformedUseValue = provider.useValue;
       let transformedUseExisting = provider.useExisting;
       let transformedDeps: CompileDiDependencyMetadata[];
       if (isPresent(provider.useExisting)) {
-        const existingDiDep = this._getDependency(
-            new CompileDiDependencyMetadata({token: provider.useExisting}), eager,
-            resolvedProvider.sourceSpan);
+        const existingDiDep =
+            this._getDependency({token: provider.useExisting}, eager, resolvedProvider.sourceSpan);
         if (isPresent(existingDiDep.token)) {
           transformedUseExisting = existingDiDep.token;
         } else {
@@ -353,7 +341,7 @@ export class NgModuleProviderAnalyzer {
     });
     transformedProviderAst =
         _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});
-    this._transformedProviders.set(token.reference, transformedProviderAst);
+    this._transformedProviders.set(tokenReference(token), transformedProviderAst);
     return transformedProviderAst;
   }
 
@@ -363,9 +351,8 @@ export class NgModuleProviderAnalyzer {
     let foundLocal = false;
     if (!dep.isSkipSelf && isPresent(dep.token)) {
       // access the injector
-      if (dep.token.reference === resolveIdentifierToken(Identifiers.Injector).reference ||
-          dep.token.reference ===
-              resolveIdentifierToken(Identifiers.ComponentFactoryResolver).reference) {
+      if (tokenReference(dep.token) === resolveIdentifier(Identifiers.Injector) ||
+          tokenReference(dep.token) === resolveIdentifier(Identifiers.ComponentFactoryResolver)) {
         foundLocal = true;
         // access providers
       } else if (isPresent(this._getOrCreateLocalProvider(dep.token, eager))) {
@@ -375,10 +362,10 @@ export class NgModuleProviderAnalyzer {
     let result: CompileDiDependencyMetadata = dep;
     if (dep.isSelf && !foundLocal) {
       if (dep.isOptional) {
-        result = new CompileDiDependencyMetadata({isValue: true, value: null});
+        result = {isValue: true, value: null};
       } else {
         this._errors.push(
-            new ProviderError(`No provider for ${dep.token.name}`, requestorSourceSpan));
+            new ProviderError(`No provider for ${tokenName(dep.token)}`, requestorSourceSpan));
       }
     }
     return result;
@@ -389,7 +376,7 @@ function _transformProvider(
     provider: CompileProviderMetadata,
     {useExisting, useValue, deps}:
         {useExisting: CompileTokenMetadata, useValue: any, deps: CompileDiDependencyMetadata[]}) {
-  return new CompileProviderMetadata({
+  return {
     token: provider.token,
     useClass: provider.useClass,
     useExisting: useExisting,
@@ -397,7 +384,7 @@ function _transformProvider(
     useValue: useValue,
     deps: deps,
     multi: provider.multi
-  });
+  };
 }
 
 function _transformProviderAst(
@@ -408,44 +395,13 @@ function _transformProviderAst(
       provider.providerType, provider.lifecycleHooks, provider.sourceSpan);
 }
 
-function _normalizeProviders(
-    providers: Array<CompileProviderMetadata|CompileTypeMetadata|any[]>,
-    sourceSpan: ParseSourceSpan, targetErrors: ParseError[],
-    targetProviders: CompileProviderMetadata[] = null): CompileProviderMetadata[] {
-  if (!targetProviders) {
-    targetProviders = [];
-  }
-  if (isPresent(providers)) {
-    providers.forEach((provider) => {
-      if (Array.isArray(provider)) {
-        _normalizeProviders(<any[]>provider, sourceSpan, targetErrors, targetProviders);
-      } else {
-        let normalizeProvider: CompileProviderMetadata;
-        if (provider instanceof CompileProviderMetadata) {
-          normalizeProvider = provider;
-        } else if (provider instanceof CompileTypeMetadata) {
-          normalizeProvider = new CompileProviderMetadata(
-              {token: new CompileTokenMetadata({identifier: provider}), useClass: provider});
-        } else {
-          targetErrors.push(new ProviderError(`Unknown provider type ${provider}`, sourceSpan));
-        }
-        if (isPresent(normalizeProvider)) {
-          targetProviders.push(normalizeProvider);
-        }
-      }
-    });
-  }
-  return targetProviders;
-}
-
-
 function _resolveProvidersFromDirectives(
     directives: CompileDirectiveSummary[], sourceSpan: ParseSourceSpan,
     targetErrors: ParseError[]): Map<any, ProviderAst> {
   const providersByToken = new Map<any, ProviderAst>();
   directives.forEach((directive) => {
-    const dirProvider = new CompileProviderMetadata(
-        {token: new CompileTokenMetadata({identifier: directive.type}), useClass: directive.type});
+    const dirProvider:
+        CompileProviderMetadata = {token: {identifier: directive.type}, useClass: directive.type};
     _resolveProviders(
         [dirProvider],
         directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive, true,
@@ -457,11 +413,11 @@ function _resolveProvidersFromDirectives(
       directives.filter(dir => dir.isComponent).concat(directives.filter(dir => !dir.isComponent));
   directivesWithComponentFirst.forEach((directive) => {
     _resolveProviders(
-        _normalizeProviders(directive.providers, sourceSpan, targetErrors),
-        ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken);
+        directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors,
+        providersByToken);
     _resolveProviders(
-        _normalizeProviders(directive.viewProviders, sourceSpan, targetErrors),
-        ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken);
+        directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors,
+        providersByToken);
   });
   return providersByToken;
 }
@@ -471,21 +427,21 @@ function _resolveProviders(
     sourceSpan: ParseSourceSpan, targetErrors: ParseError[],
     targetProvidersByToken: Map<any, ProviderAst>) {
   providers.forEach((provider) => {
-    let resolvedProvider = targetProvidersByToken.get(provider.token.reference);
-    if (isPresent(resolvedProvider) && resolvedProvider.multiProvider !== provider.multi) {
+    let resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));
+    if (isPresent(resolvedProvider) && !!resolvedProvider.multiProvider !== !!provider.multi) {
       targetErrors.push(new ProviderError(
-          `Mixing multi and non multi provider is not possible for token ${resolvedProvider.token.name}`,
+          `Mixing multi and non multi provider is not possible for token ${tokenName(resolvedProvider.token)}`,
           sourceSpan));
     }
     if (!resolvedProvider) {
-      const lifecycleHooks =
-          provider.token.identifier && provider.token.identifier instanceof CompileTypeMetadata ?
-          provider.token.identifier.lifecycleHooks :
+      const lifecycleHooks = provider.token.identifier &&
+              (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks ?
+          (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks :
           [];
       resolvedProvider = new ProviderAst(
           provider.token, provider.multi, eager || lifecycleHooks.length > 0, [provider],
           providerType, lifecycleHooks, sourceSpan);
-      targetProvidersByToken.set(provider.token.reference, resolvedProvider);
+      targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);
     } else {
       if (!provider.multi) {
         resolvedProvider.providers.length = 0;
@@ -517,10 +473,10 @@ function _getContentQueries(directives: CompileDirectiveSummary[]):
 
 function _addQueryToTokenMap(map: Map<any, CompileQueryMetadata[]>, query: CompileQueryMetadata) {
   query.selectors.forEach((token: CompileTokenMetadata) => {
-    let entry = map.get(token.reference);
+    let entry = map.get(tokenReference(token));
     if (!entry) {
       entry = [];
-      map.set(token.reference, entry);
+      map.set(tokenReference(token), entry);
     }
     entry.push(query);
   });

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

@@ -297,12 +297,12 @@ export class SelectorMatcher {
       return false;
     }
 
-    let selectables = map.get(name);
-    const starSelectables = map.get('*');
+    let selectables: SelectorContext[] = map.get(name) || [];
+    const starSelectables: SelectorContext[] = map.get('*');
     if (starSelectables) {
       selectables = selectables.concat(starSelectables);
     }
-    if (!selectables) {
+    if (selectables.length === 0) {
       return false;
     }
     let selectable: SelectorContext;

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

@@ -7,7 +7,8 @@
  */
 
 import {Injectable, ViewEncapsulation} from '@angular/core';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileStylesheetMetadata} from './compile_metadata';
+
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileStylesheetMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
 import * as o from './output/output_ast';
 import {ShadowCss} from './shadow_css';
 import {UrlResolver} from './url_resolver';
@@ -18,7 +19,7 @@ const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
 
 export class StylesCompileDependency {
   constructor(
-      public moduleUrl: string, public isShimmed: boolean,
+      public name: string, public moduleUrl: string, public isShimmed: boolean,
       public valuePlaceholder: CompileIdentifierMetadata) {}
 }
 
@@ -47,7 +48,7 @@ export class StyleCompiler {
         comp, new CompileStylesheetMetadata({
           styles: comp.template.styles,
           styleUrls: comp.template.styleUrls,
-          moduleUrl: comp.type.moduleUrl
+          moduleUrl: identifierModuleUrl(comp.type)
         }),
         true);
     comp.template.externalStylesheets.forEach((stylesheetMeta) => {
@@ -65,8 +66,9 @@ export class StyleCompiler {
         stylesheet.styles.map(plainStyle => o.literal(this._shimIfNeeded(plainStyle, shim)));
     const dependencies: StylesCompileDependency[] = [];
     for (let i = 0; i < stylesheet.styleUrls.length; i++) {
-      const identifier = new CompileIdentifierMetadata({name: getStylesVarName(null)});
-      dependencies.push(new StylesCompileDependency(stylesheet.styleUrls[i], shim, identifier));
+      const identifier: CompileIdentifierMetadata = {reference: null};
+      dependencies.push(new StylesCompileDependency(
+          getStylesVarName(null), stylesheet.styleUrls[i], shim, identifier));
       styleExpressions.push(new o.ExternalExpr(identifier));
     }
     // styles variable contains plain strings and arrays of other styles arrays (recursive),
@@ -87,7 +89,7 @@ export class StyleCompiler {
 function getStylesVarName(component: CompileDirectiveMetadata): string {
   let result = `styles`;
   if (component) {
-    result += `_${component.type.name}`;
+    result += `_${identifierName(component.type)}`;
   }
   return result;
 }

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

@@ -0,0 +1,14 @@
+/**
+ * @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 {Injectable} from '@angular/core';
+import {CompileTypeSummary} from './compile_metadata';
+
+@Injectable()
+export class SummaryResolver {
+  resolveSummary(reference: any): CompileTypeSummary { return null; }
+}

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

@@ -9,13 +9,12 @@
 import {SecurityContext} from '@angular/core';
 
 import {CompileDirectiveSummary, CompilePipeSummary} from '../compile_metadata';
-import {AST, ASTWithSource, BindingPipe, EmptyExpr, Interpolation, LiteralPrimitive, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
+import {ASTWithSource, BindingPipe, EmptyExpr, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
 import {Parser} from '../expression_parser/parser';
 import {isPresent} from '../facade/lang';
-import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';
+import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {mergeNsAndName} from '../ml_parser/tags';
 import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
-import {view_utils} from '../private_import_core';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {CssSelector} from '../selector';
 import {splitAtColon, splitAtPeriod} from '../util';
@@ -246,18 +245,12 @@ export class BindingParser {
 
     let unit: string = null;
     let bindingType: PropertyBindingType;
-    let boundPropertyName: string;
+    let boundPropertyName: string = null;
     const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
     let securityContexts: SecurityContext[];
 
-    if (parts.length === 1) {
-      const partValue = parts[0];
-      boundPropertyName = this._schemaRegistry.getMappedPropName(partValue);
-      securityContexts = calcPossibleSecurityContexts(
-          this._schemaRegistry, elementSelector, boundPropertyName, false);
-      bindingType = PropertyBindingType.Property;
-      this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);
-    } else {
+    // Check check for special cases (prefix style, attr, class)
+    if (parts.length > 1) {
       if (parts[0] == ATTRIBUTE_PREFIX) {
         boundPropertyName = parts[1];
         this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
@@ -281,12 +274,18 @@ export class BindingParser {
         boundPropertyName = parts[1];
         bindingType = PropertyBindingType.Style;
         securityContexts = [SecurityContext.STYLE];
-      } else {
-        this._reportError(`Invalid property name '${boundProp.name}'`, boundProp.sourceSpan);
-        bindingType = null;
-        securityContexts = [];
       }
     }
+
+    // If not a special case, use the full property name
+    if (boundPropertyName === null) {
+      boundPropertyName = this._schemaRegistry.getMappedPropName(boundProp.name);
+      securityContexts = calcPossibleSecurityContexts(
+          this._schemaRegistry, elementSelector, boundPropertyName, false);
+      bindingType = PropertyBindingType.Property;
+      this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);
+    }
+
     return new BoundElementPropertyAst(
         boundPropertyName, bindingType, securityContexts.length === 1 ? securityContexts[0] : null,
         securityContexts.length > 1, boundProp.expression, unit, boundProp.sourceSpan);
@@ -378,9 +377,12 @@ export class BindingParser {
     if (isPresent(ast)) {
       const collector = new PipeCollector();
       ast.visit(collector);
-      collector.pipes.forEach((pipeName) => {
+      collector.pipes.forEach((ast, pipeName) => {
         if (!this.pipesByName.has(pipeName)) {
-          this._reportError(`The pipe '${pipeName}' could not be found`, sourceSpan);
+          this._reportError(
+              `The pipe '${pipeName}' could not be found`,
+              new ParseSourceSpan(
+                  sourceSpan.start.moveBy(ast.span.start), sourceSpan.start.moveBy(ast.span.end)));
         }
       });
     }
@@ -403,9 +405,9 @@ export class BindingParser {
 }
 
 export class PipeCollector extends RecursiveAstVisitor {
-  pipes = new Set<string>();
+  pipes = new Map<string, BindingPipe>();
   visitPipe(ast: BindingPipe, context: any): any {
-    this.pipes.add(ast.name);
+    this.pipes.set(ast.name, ast);
     ast.exp.visit(this);
     this.visitAll(ast.args, context);
     return null;

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

@@ -6,21 +6,20 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Inject, Injectable, OpaqueToken, Optional, SchemaMetadata, SecurityContext} from '@angular/core';
+import {Inject, Injectable, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
 
-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeSummary, CompileTemplateMetadata, CompileTemplateSummary, CompileTokenMetadata, CompileTypeMetadata, removeIdentifierDuplicates} from '../compile_metadata';
-import {AST, ASTWithSource, BindingPipe, EmptyExpr, Interpolation, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeSummary, CompileTemplateSummary, CompileTokenMetadata, CompileTypeMetadata, identifierName} from '../compile_metadata';
 import {Parser} from '../expression_parser/parser';
 import {isPresent} from '../facade/lang';
 import {I18NHtmlParser} from '../i18n/i18n_html_parser';
-import {Identifiers, identifierToken, resolveIdentifierToken} from '../identifiers';
+import {Identifiers, createIdentifierToken, identifierToken} from '../identifiers';
 import * as html from '../ml_parser/ast';
 import {ParseTreeResult} from '../ml_parser/html_parser';
 import {expandNodes} from '../ml_parser/icu_ast_expander';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
-import {mergeNsAndName, splitNsName} from '../ml_parser/tags';
+import {splitNsName} from '../ml_parser/tags';
 import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
-import {Console, view_utils} from '../private_import_core';
+import {Console} from '../private_import_core';
 import {ProviderElementContext, ProviderViewContext} from '../provider_analyzer';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {CssSelector, SelectorMatcher} from '../selector';
@@ -30,8 +29,6 @@ import {BindingParser, BoundProperty} from './binding_parser';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from './template_ast';
 import {PreparsedElementType, preparseElement} from './template_preparser';
 
-
-
 // Group 1 = "bind-"
 // Group 2 = "let-"
 // Group 3 = "ref-/#"
@@ -546,7 +543,8 @@ class TemplateParseVisitor implements html.Visitor {
     let component: CompileDirectiveSummary = null;
     const directiveAsts = directives.map((directive) => {
       const sourceSpan = new ParseSourceSpan(
-          elementSourceSpan.start, elementSourceSpan.end, `Directive ${directive.type.name}`);
+          elementSourceSpan.start, elementSourceSpan.end,
+          `Directive ${identifierName(directive.type)}`);
       if (directive.isComponent) {
         component = directive;
       }
@@ -579,7 +577,7 @@ class TemplateParseVisitor implements html.Visitor {
       } else if (!component) {
         let refToken: CompileTokenMetadata = null;
         if (isTemplateElement) {
-          refToken = resolveIdentifierToken(Identifiers.TemplateRef);
+          refToken = createIdentifierToken(Identifiers.TemplateRef);
         }
         targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
       }
@@ -640,7 +638,7 @@ class TemplateParseVisitor implements html.Visitor {
 
   private _findComponentDirectiveNames(directives: DirectiveAst[]): string[] {
     return this._findComponentDirectives(directives)
-        .map(directive => directive.directive.type.name);
+        .map(directive => identifierName(directive.directive.type));
   }
 
   private _assertOnlyOneComponent(directives: DirectiveAst[], sourceSpan: ParseSourceSpan) {
@@ -684,7 +682,7 @@ class TemplateParseVisitor implements html.Visitor {
     }
     elementProps.forEach(prop => {
       this._reportError(
-          `Property binding ${prop.name} not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the "directives" section.`,
+          `Property binding ${prop.name} not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the "@NgModule.declarations".`,
           sourceSpan);
     });
   }
@@ -703,7 +701,7 @@ class TemplateParseVisitor implements html.Visitor {
     events.forEach(event => {
       if (isPresent(event.target) || !allDirectiveEvents.has(event.name)) {
         this._reportError(
-            `Event binding ${event.fullName} not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the "directives" section.`,
+            `Event binding ${event.fullName} not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the "@NgModule.declarations".`,
             event.sourceSpan);
       }
     });
@@ -812,7 +810,8 @@ class ElementContext {
   }
 }
 
-function createElementCssSelector(elementName: string, matchableAttrs: string[][]): CssSelector {
+export function createElementCssSelector(
+    elementName: string, matchableAttrs: string[][]): CssSelector {
   const cssSelector = new CssSelector();
   const elNameNoNs = splitNsName(elementName)[1];
 

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

@@ -35,10 +35,6 @@ function _splitAt(input: string, character: string, defaultValues: string[]): st
   return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];
 }
 
-export function sanitizeIdentifier(name: string): string {
-  return name.replace(/\W/g, '_');
-}
-
 export function visitValue(value: any, visitor: ValueVisitor, context: any): any {
   if (Array.isArray(value)) {
     return visitor.visitArray(<any[]>value, context);

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * @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');

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

@@ -7,11 +7,11 @@
  */
 
 
-import {CompileDiDependencyMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata} from '../compile_metadata';
+import {CompileDiDependencyMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, identifierName, tokenName, tokenReference} from '../compile_metadata';
 import {createDiTokenExpression} from '../compiler_util/identifier_util';
 import {DirectiveWrapperCompiler, DirectiveWrapperExpressions} from '../directive_wrapper_compiler';
 import {isPresent} from '../facade/lang';
-import {Identifiers, identifierToken, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
+import {Identifiers, createIdentifier, createIdentifierToken, identifierToken, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {convertValueToOutputAst} from '../output/value_util';
 import {ProviderAst, ProviderAstType, ReferenceAst, TemplateAst} from '../template_parser/template_ast';
@@ -20,7 +20,7 @@ import {CompileMethod} from './compile_method';
 import {CompileQuery, addQueryToTokenMap, createQueryList} from './compile_query';
 import {CompileView, CompileViewRootNode} from './compile_view';
 import {InjectMethodVars, ViewProperties} from './constants';
-import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency} from './deps';
+import {ComponentFactoryDependency, DirectiveWrapperDependency} from './deps';
 import {getPropertyInView, injectFromViewParentInjector} from './util';
 
 export class CompileNode {
@@ -35,7 +35,7 @@ export class CompileNode {
 
 export class CompileElement extends CompileNode {
   static createNull(): CompileElement {
-    return new CompileElement(null, null, null, null, null, null, [], [], false, false, [], []);
+    return new CompileElement(null, null, null, null, null, null, [], [], false, false, []);
   }
 
   public compViewExpr: o.Expression = null;
@@ -57,21 +57,18 @@ export class CompileElement extends CompileNode {
       sourceAst: TemplateAst, public component: CompileDirectiveSummary,
       private _directives: CompileDirectiveSummary[],
       private _resolvedProvidersArray: ProviderAst[], public hasViewContainer: boolean,
-      public hasEmbeddedView: boolean, references: ReferenceAst[],
-      private _targetDependencies:
-          Array<ViewClassDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {
+      public hasEmbeddedView: boolean, references: ReferenceAst[]) {
     super(parent, view, nodeIndex, renderNode, sourceAst);
     this.referenceTokens = {};
     references.forEach(ref => this.referenceTokens[ref.name] = ref.value);
 
     this.elementRef =
-        o.importExpr(resolveIdentifier(Identifiers.ElementRef)).instantiate([this.renderNode]);
-    this.instances.set(resolveIdentifierToken(Identifiers.ElementRef).reference, this.elementRef);
+        o.importExpr(createIdentifier(Identifiers.ElementRef)).instantiate([this.renderNode]);
+    this.instances.set(resolveIdentifier(Identifiers.ElementRef), this.elementRef);
     this.instances.set(
-        resolveIdentifierToken(Identifiers.Injector).reference,
+        resolveIdentifier(Identifiers.Injector),
         o.THIS_EXPR.callMethod('injector', [o.literal(this.nodeIndex)]));
-    this.instances.set(
-        resolveIdentifierToken(Identifiers.Renderer).reference, o.THIS_EXPR.prop('renderer'));
+    this.instances.set(resolveIdentifier(Identifiers.Renderer), o.THIS_EXPR.prop('renderer'));
     if (this.hasViewContainer || this.hasEmbeddedView) {
       this._createViewContainer();
     }
@@ -85,41 +82,40 @@ export class CompileElement extends CompileNode {
     const parentNodeIndex = this.isRootElement() ? null : this.parent.nodeIndex;
     // private is fine here as no child view will reference a ViewContainer
     this.view.fields.push(new o.ClassField(
-        fieldName, o.importType(resolveIdentifier(Identifiers.ViewContainer)),
+        fieldName, o.importType(createIdentifier(Identifiers.ViewContainer)),
         [o.StmtModifier.Private]));
     const statement =
         o.THIS_EXPR.prop(fieldName)
-            .set(o.importExpr(resolveIdentifier(Identifiers.ViewContainer)).instantiate([
+            .set(o.importExpr(createIdentifier(Identifiers.ViewContainer)).instantiate([
               o.literal(this.nodeIndex), o.literal(parentNodeIndex), o.THIS_EXPR, this.renderNode
             ]))
             .toStmt();
     this.view.createMethod.addStmt(statement);
     this.viewContainer = o.THIS_EXPR.prop(fieldName);
-    this.instances.set(
-        resolveIdentifierToken(Identifiers.ViewContainer).reference, this.viewContainer);
+    this.instances.set(resolveIdentifier(Identifiers.ViewContainer), this.viewContainer);
     this.view.viewContainers.push(this.viewContainer);
   }
 
   private _createComponentFactoryResolver() {
     const entryComponents =
         this.component.entryComponents.map((entryComponent: CompileIdentifierMetadata) => {
-          const id = new CompileIdentifierMetadata({name: entryComponent.name});
-          this._targetDependencies.push(new ComponentFactoryDependency(entryComponent, id));
+          const id: CompileIdentifierMetadata = {reference: null};
+          this.view.targetDependencies.push(new ComponentFactoryDependency(entryComponent, id));
           return id;
         });
     if (!entryComponents || entryComponents.length === 0) {
       return;
     }
     const createComponentFactoryResolverExpr =
-        o.importExpr(resolveIdentifier(Identifiers.CodegenComponentFactoryResolver)).instantiate([
+        o.importExpr(createIdentifier(Identifiers.CodegenComponentFactoryResolver)).instantiate([
           o.literalArr(entryComponents.map((entryComponent) => o.importExpr(entryComponent))),
           injectFromViewParentInjector(
-              this.view, resolveIdentifierToken(Identifiers.ComponentFactoryResolver), false)
+              this.view, createIdentifierToken(Identifiers.ComponentFactoryResolver), false)
         ]);
-    const provider = new CompileProviderMetadata({
-      token: resolveIdentifierToken(Identifiers.ComponentFactoryResolver),
+    const provider: CompileProviderMetadata = {
+      token: createIdentifierToken(Identifiers.ComponentFactoryResolver),
       useValue: createComponentFactoryResolverExpr
-    });
+    };
     // Add ComponentFactoryResolver as first provider as it does not have deps on other providers
     // ProviderAstType.PrivateService as only the component and its view can see it,
     // but nobody else
@@ -141,13 +137,13 @@ export class CompileElement extends CompileNode {
     this.embeddedView = embeddedView;
     if (isPresent(embeddedView)) {
       const createTemplateRefExpr =
-          o.importExpr(resolveIdentifier(Identifiers.TemplateRef_)).instantiate([
+          o.importExpr(createIdentifier(Identifiers.TemplateRef_)).instantiate([
             o.THIS_EXPR, o.literal(this.nodeIndex), this.renderNode
           ]);
-      const provider = new CompileProviderMetadata({
-        token: resolveIdentifierToken(Identifiers.TemplateRef),
+      const provider: CompileProviderMetadata = {
+        token: createIdentifierToken(Identifiers.TemplateRef),
         useValue: createTemplateRefExpr
-      });
+      };
       // Add TemplateRef as first provider as it does not have deps on other providers
       this._resolvedProvidersArray.unshift(new ProviderAst(
           provider.token, false, true, [provider], ProviderAstType.Builtin, [],
@@ -158,13 +154,12 @@ export class CompileElement extends CompileNode {
   beforeChildren(): void {
     if (this.hasViewContainer) {
       this.instances.set(
-          resolveIdentifierToken(Identifiers.ViewContainerRef).reference,
-          this.viewContainer.prop('vcRef'));
+          resolveIdentifier(Identifiers.ViewContainerRef), this.viewContainer.prop('vcRef'));
     }
 
     this._resolvedProviders = new Map<any, ProviderAst>();
     this._resolvedProvidersArray.forEach(
-        provider => this._resolvedProviders.set(provider.token.reference, provider));
+        provider => this._resolvedProviders.set(tokenReference(provider.token), provider));
 
     // create all the provider instances, some in the view constructor,
     // some as getters. We rely on the fact that they are already sorted topologically.
@@ -173,9 +168,7 @@ export class CompileElement extends CompileNode {
           resolvedProvider.providerType === ProviderAstType.Directive;
       const providerValueExpressions = resolvedProvider.providers.map((provider) => {
         if (provider.useExisting) {
-          return this._getDependency(
-              resolvedProvider.providerType,
-              new CompileDiDependencyMetadata({token: provider.useExisting}));
+          return this._getDependency(resolvedProvider.providerType, {token: provider.useExisting});
         } else if (provider.useFactory) {
           const deps = provider.deps || provider.useFactory.diDeps;
           const depsExpr =
@@ -186,10 +179,10 @@ export class CompileElement extends CompileNode {
           const depsExpr =
               deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep));
           if (isDirectiveWrapper) {
-            const directiveWrapperIdentifier = new CompileIdentifierMetadata(
-                {name: DirectiveWrapperCompiler.dirWrapperClassName(provider.useClass)});
-            this._targetDependencies.push(
-                new DirectiveWrapperDependency(provider.useClass, directiveWrapperIdentifier));
+            const directiveWrapperIdentifier: CompileIdentifierMetadata = {reference: null};
+            this.view.targetDependencies.push(new DirectiveWrapperDependency(
+                provider.useClass, DirectiveWrapperCompiler.dirWrapperClassName(provider.useClass),
+                directiveWrapperIdentifier));
             return DirectiveWrapperExpressions.create(directiveWrapperIdentifier, depsExpr);
           } else {
             return o.importExpr(provider.useClass)
@@ -199,22 +192,23 @@ export class CompileElement extends CompileNode {
           return convertValueToOutputAst(provider.useValue);
         }
       });
-      const propName = `_${resolvedProvider.token.name}_${this.nodeIndex}_${this.instances.size}`;
+      const propName =
+          `_${tokenName(resolvedProvider.token)}_${this.nodeIndex}_${this.instances.size}`;
       const instance = createProviderProperty(
           propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider,
           resolvedProvider.eager, this);
       if (isDirectiveWrapper) {
-        this.directiveWrapperInstance.set(resolvedProvider.token.reference, instance);
+        this.directiveWrapperInstance.set(tokenReference(resolvedProvider.token), instance);
         this.instances.set(
-            resolvedProvider.token.reference, DirectiveWrapperExpressions.context(instance));
+            tokenReference(resolvedProvider.token), DirectiveWrapperExpressions.context(instance));
       } else {
-        this.instances.set(resolvedProvider.token.reference, instance);
+        this.instances.set(tokenReference(resolvedProvider.token), instance);
       }
     });
 
     for (let i = 0; i < this._directives.length; i++) {
       const directive = this._directives[i];
-      const directiveInstance = this.instances.get(identifierToken(directive.type).reference);
+      const directiveInstance = this.instances.get(tokenReference(identifierToken(directive.type)));
       directive.queries.forEach((queryMeta) => { this._addQuery(queryMeta, directiveInstance); });
     }
     const queriesWithReads: _QueryWithRead[] = [];
@@ -227,12 +221,12 @@ export class CompileElement extends CompileNode {
       const token = this.referenceTokens[varName];
       let varValue: o.Expression;
       if (token) {
-        varValue = this.instances.get(token.reference);
+        varValue = this.instances.get(tokenReference(token));
       } else {
         varValue = this.renderNode;
       }
       this.view.locals.set(varName, varValue);
-      const varToken = new CompileTokenMetadata({value: varName});
+      const varToken = {value: varName};
       queriesWithReads.push(
           ...this._getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
     });
@@ -240,12 +234,12 @@ export class CompileElement extends CompileNode {
       let value: o.Expression;
       if (isPresent(queryWithRead.read.identifier)) {
         // query for an identifier
-        value = this.instances.get(queryWithRead.read.reference);
+        value = this.instances.get(tokenReference(queryWithRead.read));
       } else {
         // query for a reference
         const token = this.referenceTokens[queryWithRead.read.value];
         if (isPresent(token)) {
-          value = this.instances.get(token.reference);
+          value = this.instances.get(tokenReference(token));
         } else {
           value = this.elementRef;
         }
@@ -261,7 +255,7 @@ export class CompileElement extends CompileNode {
       // Note: afterChildren is called after recursing into children.
       // This is good so that an injector match in an element that is closer to a requesting element
       // matches first.
-      const providerExpr = this.instances.get(resolvedProvider.token.reference);
+      const providerExpr = this.instances.get(tokenReference(resolvedProvider.token));
       // Note: view providers are only visible on the injector of that element.
       // This is not fully correct as the rules during codegen don't allow a directive
       // to get hold of a view provdier on the same element. We still do this semantic
@@ -285,7 +279,7 @@ export class CompileElement extends CompileNode {
 
   getComponent(): o.Expression {
     return isPresent(this.component) ?
-        this.instances.get(identifierToken(this.component.type).reference) :
+        this.instances.get(tokenReference(identifierToken(this.component.type))) :
         null;
   }
 
@@ -300,7 +294,7 @@ export class CompileElement extends CompileNode {
     let distance = 0;
     let queries: CompileQuery[];
     while (!currentEl.isNull()) {
-      queries = currentEl._queries.get(token.reference);
+      queries = currentEl._queries.get(tokenReference(token));
       if (isPresent(queries)) {
         result.push(...queries.filter((query) => query.meta.descendants || distance <= 1));
       }
@@ -309,7 +303,7 @@ export class CompileElement extends CompileNode {
       }
       currentEl = currentEl.parent;
     }
-    queries = this.view.componentView.viewQueries.get(token.reference);
+    queries = this.view.componentView.viewQueries.get(tokenReference(token));
     if (isPresent(queries)) {
       result.push(...queries);
     }
@@ -319,7 +313,7 @@ export class CompileElement extends CompileNode {
   private _addQuery(queryMeta: CompileQueryMetadata, directiveInstance: o.Expression):
       CompileQuery {
     const propName =
-        `_query_${queryMeta.selectors[0].name}_${this.nodeIndex}_${this._queryCount++}`;
+        `_query_${tokenName(queryMeta.selectors[0])}_${this.nodeIndex}_${this._queryCount++}`;
     const queryList = createQueryList(queryMeta, directiveInstance, propName, this.view);
     const query = new CompileQuery(queryMeta, queryList, directiveInstance, this.view);
     addQueryToTokenMap(this._queries, query);
@@ -332,8 +326,7 @@ export class CompileElement extends CompileNode {
     if (isPresent(dep.token)) {
       // access builtins with special visibility
       if (!result) {
-        if (dep.token.reference ===
-            resolveIdentifierToken(Identifiers.ChangeDetectorRef).reference) {
+        if (tokenReference(dep.token) === resolveIdentifier(Identifiers.ChangeDetectorRef)) {
           if (requestingProviderType === ProviderAstType.Component) {
             return this.compViewExpr.prop('ref');
           } else {
@@ -343,7 +336,7 @@ export class CompileElement extends CompileNode {
       }
       // access regular providers on the element
       if (!result) {
-        const resolvedProvider = this._resolvedProviders.get(dep.token.reference);
+        const resolvedProvider = this._resolvedProviders.get(tokenReference(dep.token));
         // don't allow directives / public services to access private services.
         // only components and private services can access private services.
         if (resolvedProvider && (requestingProviderType === ProviderAstType.Directive ||
@@ -351,7 +344,7 @@ export class CompileElement extends CompileNode {
             resolvedProvider.providerType === ProviderAstType.PrivateService) {
           return null;
         }
-        result = this.instances.get(dep.token.reference);
+        result = this.instances.get(tokenReference(dep.token));
       }
     }
     return result;
@@ -370,8 +363,7 @@ export class CompileElement extends CompileNode {
     // check parent elements
     while (!result && !currElement.parent.isNull()) {
       currElement = currElement.parent;
-      result = currElement._getLocalDependency(
-          ProviderAstType.PublicService, new CompileDiDependencyMetadata({token: dep.token}));
+      result = currElement._getLocalDependency(ProviderAstType.PublicService, {token: dep.token});
     }
 
     if (!result) {

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

@@ -7,9 +7,9 @@
  */
 
 
-import {CompilePipeSummary} from '../compile_metadata';
+import {CompilePipeSummary, tokenReference} from '../compile_metadata';
 import {createPureProxy} from '../compiler_util/identifier_util';
-import {Identifiers, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
+import {Identifiers, createIdentifier, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 
 import {CompileView} from './compile_view';
@@ -42,8 +42,7 @@ export class CompilePipe {
   constructor(public view: CompileView, public meta: CompilePipeSummary) {
     this.instance = o.THIS_EXPR.prop(`_pipe_${meta.name}_${view.pipeCount++}`);
     const deps = this.meta.type.diDeps.map((diDep) => {
-      if (diDep.token.reference ===
-          resolveIdentifierToken(Identifiers.ChangeDetectorRef).reference) {
+      if (tokenReference(diDep.token) === resolveIdentifier(Identifiers.ChangeDetectorRef)) {
         return getPropertyInView(o.THIS_EXPR.prop('ref'), this.view, this.view.componentView);
       }
       return injectFromViewParentInjector(view, diDep.token, false);
@@ -69,7 +68,7 @@ export class CompilePipe {
               .callMethod(o.BuiltinMethod.Bind, [pipeInstanceSeenFromPureProxy]),
           args.length, purePipeProxyInstance,
           {fields: callingView.fields, ctorStmts: callingView.createMethod});
-      return o.importExpr(resolveIdentifier(Identifiers.castByValue))
+      return o.importExpr(createIdentifier(Identifiers.castByValue))
           .callFn([purePipeProxyInstance, pipeInstanceSeenFromPureProxy.prop('transform')])
           .callFn(args);
     } else {