docs(changelog): add changelog for 2.2.4

Fixes #13146

.pullapprove.yml

@@ -1,32 +0,0 @@
-# Configuration for pullapprove.com
-# See ownership spreadsheet:
-# https://docs.google.com/spreadsheets/d/1-HIlzfbPYGsPr9KuYMe6bLfc4LXzPjpoALqtYRYTZB0/edit?pli=1#gid=0&vpid=A5
-
-version: 2
-
-group_defaults:
-  required: 1
-  reset_on_reopened:
-    enabled: true
-  approve_by_comment:
-    enabled: true
-    approve_regex: '^(Approved|:\+1:|LGTM)'
-
-groups:
-  config:
-    conditions:
-      files:
-        - "*.yml"
-        - "*.json"
-    teams:
-      - repoowners
-
-  compiler:
-    conditions:
-      files:
-        - "tools/@angular/tsc-wrapped/*"
-        - "modules/@angular/compiler/*"
-        - "modules/@angular/compiler-cli/*"
-    teams:
-      - compiler-owners
-      - repoowners

CHANGELOG.md

@@ -1,236 +1,3 @@
-<a name="2.4.5"></a>
-## [2.4.5](https://github.com/angular/angular/compare/2.4.4...2.4.5) (2017-01-25)
-
-
-### Bug Fixes
-
-* **compiler:** [i18n] XMB/XTB placeholder names can contain only A-Z, 0-9, _n ([5492fad](https://github.com/angular/angular/commit/5492fad))
-* **compiler:** fix regexp to support firefox 31 ([#14082](https://github.com/angular/angular/issues/14082)) ([bd2eecb](https://github.com/angular/angular/commit/bd2eecb)), closes [#14029](https://github.com/angular/angular/issues/14029) [#13900](https://github.com/angular/angular/issues/13900)
-* **core:** export animation classes required for Renderer impl ([#14002](https://github.com/angular/angular/issues/14002)) ([fd4f9ac](https://github.com/angular/angular/commit/fd4f9ac)), closes [#14001](https://github.com/angular/angular/issues/14001)
-* **upgrade:** ensure upgraded injector is initialized early enough ([#14065](https://github.com/angular/angular/issues/14065)) ([3b2fb23](https://github.com/angular/angular/commit/3b2fb23)), closes [#13811](https://github.com/angular/angular/issues/13811)
-
-
-
-<a name="2.4.4"></a>
-## [2.4.4](https://github.com/angular/angular/compare/2.4.3...2.4.4) (2017-01-19)
-
-
-### Bug Fixes
-
-* **animations:** fix internal jscompiler issue and AOT quoting ([#13798](https://github.com/angular/angular/issues/13798)) ([261fd16](https://github.com/angular/angular/commit/261fd16))
-* **common:** support numeric value as discrete cases for NgPlural ([#13876](https://github.com/angular/angular/issues/13876)) ([3d0b1b8](https://github.com/angular/angular/commit/3d0b1b8))
-* **http:** don't create a blob out of ArrayBuffer when type is application/octet-stream ([#13992](https://github.com/angular/angular/issues/13992)) ([015878a](https://github.com/angular/angular/commit/015878a)), closes [#13973](https://github.com/angular/angular/issues/13973)
-* **router:** enable loadChildren with function in aot ([#13909](https://github.com/angular/angular/issues/13909)) ([2af5862](https://github.com/angular/angular/commit/2af5862)), closes [#11075](https://github.com/angular/angular/issues/11075)
-* **router:** routerLinkActive should not throw when not initialized ([#13273](https://github.com/angular/angular/issues/13273)) ([49c4b0f](https://github.com/angular/angular/commit/49c4b0f)), closes [#13270](https://github.com/angular/angular/issues/13270)
-* **security:** allow calc and gradient functions. ([#13943](https://github.com/angular/angular/issues/13943)) ([bd15110](https://github.com/angular/angular/commit/bd15110))
-* **upgrade:** detect async downgrade component changes ([#13812](https://github.com/angular/angular/issues/13812)) ([2250082](https://github.com/angular/angular/commit/2250082)), closes [#6385](https://github.com/angular/angular/issues/6385) [#6385](https://github.com/angular/angular/issues/6385) [#10660](https://github.com/angular/angular/issues/10660) [#12318](https://github.com/angular/angular/issues/12318) [#12034](https://github.com/angular/angular/issues/12034)
-
-
-
-<a name="2.4.3"></a>
-## [2.4.3](https://github.com/angular/angular/compare/2.4.2...2.4.3) (2017-01-11)
-
-
-### Bug Fixes
-
-* **compiler:** avoid evaluating arguments to unknown decorators ([5e9d3db](https://github.com/angular/angular/commit/5e9d3db)), closes [#13605](https://github.com/angular/angular/issues/13605)
-* **compiler:** fix template binding parsing (`*directive="-..."`) ([7dc12b9](https://github.com/angular/angular/commit/7dc12b9)), closes [#13800](https://github.com/angular/angular/issues/13800)
-* **compiler-cli:** add support for more than 2 levels of nested lazy routes ([6164eb2](https://github.com/angular/angular/commit/6164eb2)), closes [angular/angular-cli#3663](https://github.com/angular/angular-cli/issues/3663)
-* **compiler-cli:** avoid handling functions in loadChildren as lazy load routes paths ([313683f](https://github.com/angular/angular/commit/313683f)), closes [angular/angular-cli#3204](https://github.com/angular/angular-cli/issues/3204)
-* **i18n:** translate attributes inside elements marked for translation ([d7f2a3c](https://github.com/angular/angular/commit/d7f2a3c))
-* **router:** RouterLink mirrors input `target` as attribute ([1c82b58](https://github.com/angular/angular/commit/1c82b58)), closes [#13837](https://github.com/angular/angular/issues/13837)
-* **router:** throw an error when navigate to null/undefined path ([61ba223](https://github.com/angular/angular/commit/61ba223)), closes [#10560](https://github.com/angular/angular/issues/10560) [#13384](https://github.com/angular/angular/issues/13384)
-* **router:** fix checking for object intersection ([1692265](https://github.com/angular/angular/commit/1692265))
-
-
-
-<a name="2.4.2"></a>
-## [2.4.2](https://github.com/angular/angular/compare/2.4.1...2.4.2) (2017-01-06)
-
-
-### Bug Fixes
-
-* **common:** add link to trackBy docs from the error message ([#13634](https://github.com/angular/angular/issues/13634)) ([f723437](https://github.com/angular/angular/commit/f723437))
-* **common:** do not override locale provided on bootstrap ([#13654](https://github.com/angular/angular/issues/13654)) ([5f49c3e](https://github.com/angular/angular/commit/5f49c3e)), closes [#13607](https://github.com/angular/angular/issues/13607)
-* **common:** allow null/undefined values for `NgForTrackBy` ([6be55cc](https://github.com/angular/angular/commit/6be55cc)), closes [#13641](https://github.com/angular/angular/issues/13641)
-* **compiler:** don’t throw when using `ANALYZE_FOR_ENTRY_COMPONENTS` with user classes ([#13679](https://github.com/angular/angular/issues/13679)) ([230e33f](https://github.com/angular/angular/commit/230e33f)), closes [#13565](https://github.com/angular/angular/issues/13565)
-* **compiler:** query `<template>` elements before their children. ([#13677](https://github.com/angular/angular/issues/13677)) ([1cd73c7](https://github.com/angular/angular/commit/1cd73c7)), closes [#13118](https://github.com/angular/angular/issues/13118) [#13167](https://github.com/angular/angular/issues/13167)
-* **compiler:** allow "." in attribute selectors ([#13653](https://github.com/angular/angular/issues/13653)) ([29ffdfd](https://github.com/angular/angular/commit/29ffdfd)), closes [#13645](https://github.com/angular/angular/issues/13645) [#13982](https://github.com/angular/angular/issues/13982)
-* **core:** animations no longer silently exits if the element is not apart of the DOM ([#13763](https://github.com/angular/angular/issues/13763)) ([f1cde43](https://github.com/angular/angular/commit/f1cde43))
-* **core:** animations should blend in all previously transitioned styles into next animation if interrupted ([#13148](https://github.com/angular/angular/issues/13148)) ([b245b92](https://github.com/angular/angular/commit/b245b92))
-* **core:** remove reference to "Angular 2" in dev mode warning ([#13751](https://github.com/angular/angular/issues/13751)) ([21f5f05](https://github.com/angular/angular/commit/21f5f05))
-* **core/testing:** improve misleading error message when don't call compileComponents ([#13543](https://github.com/angular/angular/issues/13543)) ([0e7f9f0](https://github.com/angular/angular/commit/0e7f9f0)), closes [#11301](https://github.com/angular/angular/issues/11301)
-* **forms:** Validators.required properly validate arrays ([#13362](https://github.com/angular/angular/issues/13362)) ([17c5fa9](https://github.com/angular/angular/commit/17c5fa9)), closes [#12274](https://github.com/angular/angular/issues/12274)
-* **language-service:** support TypeScript 2.1 ([#13655](https://github.com/angular/angular/issues/13655)) ([56b4296](https://github.com/angular/angular/commit/56b4296))
-* **router:** fix lazy loaded module with wildcard route ([#13649](https://github.com/angular/angular/issues/13649)) ([5754ecc](https://github.com/angular/angular/commit/5754ecc)), closes [#12955](https://github.com/angular/angular/issues/12955)
-* **router:** routerLink support of null ([#13380](https://github.com/angular/angular/issues/13380)) ([018865e](https://github.com/angular/angular/commit/018865e)), closes [#6971](https://github.com/angular/angular/issues/6971)
-* **router:** update route snapshot before emit new values ([#13558](https://github.com/angular/angular/issues/13558)) ([9f6a647](https://github.com/angular/angular/commit/9f6a647)), closes [#12912](https://github.com/angular/angular/issues/12912)
-* **upgrade:** fix/improve support for lifecycle hooks ([#13020](https://github.com/angular/angular/issues/13020)) ([21942a8](https://github.com/angular/angular/commit/21942a8))
-
-
-
-<a name="2.4.1"></a>
-## [2.4.1](https://github.com/angular/angular/compare/2.4.0...2.4.1) (2016-12-21)
-
-### Bug Fixes
-
-* **animations:** always quote string map key values in AOT code ([#13602](https://github.com/angular/angular/issues/13602)) ([6a5e46c](https://github.com/angular/angular/commit/6a5e46c))
-* **animations:** always recover from a failed animation step ([#13604](https://github.com/angular/angular/issues/13604)) ([d788c67](https://github.com/angular/angular/commit/d788c67))
-* **compiler:** ignore `@import` in comments ([#13368](https://github.com/angular/angular/issues/13368)) ([6316e5d](https://github.com/angular/angular/commit/6316e5d)), closes [#12196](https://github.com/angular/angular/issues/12196)
-* **core:** improve error message when component factory cannot be found ([#13541](https://github.com/angular/angular/issues/13541)) ([b9e979e](https://github.com/angular/angular/commit/b9e979e)), closes [#12678](https://github.com/angular/angular/issues/12678)
-* **router:** should reset location if a navigation by location is successful ([#13545](https://github.com/angular/angular/issues/13545)) ([a38f14b](https://github.com/angular/angular/commit/a38f14b)), closes [#13491](https://github.com/angular/angular/issues/13491)
-
-
-
-<a name="2.4.0"></a>
-# [2.4.0 stability-interjection](https://github.com/angular/angular/compare/2.3.1...2.4.0) (2016-12-20)
-
-
-### Bug Fixes
-
-* **animations:** allow players to be destroyed before initialized ([#13346](https://github.com/angular/angular/issues/13346)) ([b36f4bc](https://github.com/angular/angular/commit/b36f4bc)), closes [#13293](https://github.com/angular/angular/issues/13293)
-* **build:** use bash string comparison operator ([#13502](https://github.com/angular/angular/issues/13502)) ([50afbe0](https://github.com/angular/angular/commit/50afbe0))
-* **compiler:** do not lex `}}` when interpolation is disabled ([#13531](https://github.com/angular/angular/issues/13531)) ([9b87bb6](https://github.com/angular/angular/commit/9b87bb6)), closes [#13525](https://github.com/angular/angular/issues/13525)
-* **compiler-cli:** produce metadata for .d.ts files without metadata ([#13526](https://github.com/angular/angular/issues/13526)) ([debb0c9](https://github.com/angular/angular/commit/debb0c9)), closes [#13307](https://github.com/angular/angular/issues/13307) [#13473](https://github.com/angular/angular/issues/13473) [#13521](https://github.com/angular/angular/issues/13521)
-* **i18n:** add a default example to xmb placeholders ([#13507](https://github.com/angular/angular/issues/13507)) ([3f17841](https://github.com/angular/angular/commit/3f17841))
-* **upgrade:** fix `registerForNg1Tests` ([#13522](https://github.com/angular/angular/issues/13522)) ([c26c24c](https://github.com/angular/angular/commit/c26c24c))
-
-
-### Features
-
-* update to `rxjs@5.0.1` and unpin the rxjs peerDeps via `^5.0.1` ([#13572](https://github.com/angular/angular/issues/13572)) ([8d5da1e](https://github.com/angular/angular/commit/8d5da1e)), closes [#13561](https://github.com/angular/angular/issues/13561) [#13478](https://github.com/angular/angular/issues/13478)
-
-
-
-<a name="2.3.1"></a>
-## [2.3.1](https://github.com/angular/angular/compare/2.3.0...2.3.1) (2016-12-15)
-
-
-### Bug Fixes
-
-* **animations:** always cleanup players after they have finished internally ([#13334](https://github.com/angular/angular/issues/13334)) ([a26e054](https://github.com/angular/angular/commit/a26e054)), closes [#13333](https://github.com/angular/angular/issues/13333)
-* **animations:** throw errors and normalize offset beyond the range of [0,1] ([6557bc3](https://github.com/angular/angular/commit/6557bc3)), closes [#13348](https://github.com/angular/angular/issues/13348) [#13440](https://github.com/angular/angular/issues/13440)
-* **compiler:** emit quoted object literal keys if the source is quoted ([ecfad46](https://github.com/angular/angular/commit/ecfad46)), closes [#13249](https://github.com/angular/angular/issues/13249) [#13356](https://github.com/angular/angular/issues/13356)
-* **compiler:** fix merge error in compiler_host ([69b52eb](https://github.com/angular/angular/commit/69b52eb))
-* **compiler:** fix PR 13322 ([#13331](https://github.com/angular/angular/issues/13331)) ([79728b4](https://github.com/angular/angular/commit/79728b4))
-* **compiler:** fix simplify a reference without a name ([1c279b3](https://github.com/angular/angular/commit/1c279b3)), closes [#13470](https://github.com/angular/angular/issues/13470)
-* **compiler:** fix transpiled ES5 code ([#13322](https://github.com/angular/angular/issues/13322)) ([6c1d790](https://github.com/angular/angular/commit/6c1d790)), closes [#13301](https://github.com/angular/angular/issues/13301)
-* **compiler:** generated CSS files suffixed with ngstyle. ([#13353](https://github.com/angular/angular/issues/13353)) ([c8a9b70](https://github.com/angular/angular/commit/c8a9b70)), closes [#13141](https://github.com/angular/angular/issues/13141)
-* **compiler:** make sure provider values with `name` property don’t break. ([efa2d80](https://github.com/angular/angular/commit/efa2d80)), closes [#13394](https://github.com/angular/angular/issues/13394) [#13445](https://github.com/angular/angular/issues/13445)
-* **compiler:** narrow the span reported for invalid pipes ([307d305](https://github.com/angular/angular/commit/307d305)), closes [#13326](https://github.com/angular/angular/issues/13326) [#13411](https://github.com/angular/angular/issues/13411)
-* **compiler:** propagate exports when upgrading metadata to v2 ([f6ef7d6](https://github.com/angular/angular/commit/f6ef7d6))
-* **compiler:** resolver should merge host bindings and listeners ([#13474](https://github.com/angular/angular/issues/13474)) ([6aeaca3](https://github.com/angular/angular/commit/6aeaca3)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **compiler:** support dotted property binding ([8db184d](https://github.com/angular/angular/commit/8db184d)), closes [angular/flex-layout#34](https://github.com/angular/flex-layout/issues/34)
-* **compiler:** update to metadata version 3 ([#13464](https://github.com/angular/angular/issues/13464)) ([b9b557c](https://github.com/angular/angular/commit/b9b557c))
-* **core:** detectChanges() doesn't work on detached instance ([4d6ac9d](https://github.com/angular/angular/commit/4d6ac9d)), closes [#13426](https://github.com/angular/angular/issues/13426) [#13472](https://github.com/angular/angular/issues/13472)
-* **core:** properly destroy embedded Views attatched to ApplicationRef ([#13459](https://github.com/angular/angular/issues/13459)) ([d40bbf4](https://github.com/angular/angular/commit/d40bbf4)), closes [#13062](https://github.com/angular/angular/issues/13062)
-* **core:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
-* **forms:** ensure `select[multiple]` retains selections ([b3dcff0](https://github.com/angular/angular/commit/b3dcff0)), closes [#12527](https://github.com/angular/angular/issues/12527) [#12654](https://github.com/angular/angular/issues/12654)
-* **forms:** fix Validators.min/maxLength with FormArray ([#13095](https://github.com/angular/angular/issues/13095)) ([7383e4a](https://github.com/angular/angular/commit/7383e4a)), closes [#13089](https://github.com/angular/angular/issues/13089)
-* **forms:** introduce checkbox required validator ([124267c](https://github.com/angular/angular/commit/124267c)), closes [#11459](https://github.com/angular/angular/issues/11459) [#13364](https://github.com/angular/angular/issues/13364)
-* **http:** check response body text against undefined ([#13017](https://github.com/angular/angular/issues/13017)) ([f106a18](https://github.com/angular/angular/commit/f106a18))
-* **http:** create a copy of headers when merge options ([#13365](https://github.com/angular/angular/issues/13365)) ([65c9b5b](https://github.com/angular/angular/commit/65c9b5b)), closes [#11980](https://github.com/angular/angular/issues/11980)
-* **language-service:** correctly type `undefined` ([0a7364f](https://github.com/angular/angular/commit/0a7364f)), closes [#13412](https://github.com/angular/angular/issues/13412) [#13414](https://github.com/angular/angular/issues/13414)
-* **compiler**: better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
-* **language-service:** treat string unions as strings ([#13406](https://github.com/angular/angular/issues/13406)) ([14dd2b3](https://github.com/angular/angular/commit/14dd2b3)), closes [#13403](https://github.com/angular/angular/issues/13403)
-* **router:** add support for query params with multiple values ([e4d5a5f](https://github.com/angular/angular/commit/e4d5a5f)), closes [#11373](https://github.com/angular/angular/issues/11373)
-* **router:** Use T type in Resolve interface ([#13242](https://github.com/angular/angular/issues/13242)) ([5ee8155](https://github.com/angular/angular/commit/5ee8155))
-* **selector:** SelectorMatcher match elements with :not selector ([#12977](https://github.com/angular/angular/issues/12977)) ([392c9ac](https://github.com/angular/angular/commit/392c9ac))
-* **tsc-wrapped:** generate metadata for exports without module specifier ([cd03c77](https://github.com/angular/angular/commit/cd03c77)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **upgrade:** fix downgrade content projection and injector inheritance ([86c5098](https://github.com/angular/angular/commit/86c5098)), closes [#6629](https://github.com/angular/angular/issues/6629) [#7727](https://github.com/angular/angular/issues/7727) [#8729](https://github.com/angular/angular/issues/8729) [#9643](https://github.com/angular/angular/issues/9643) [#9649](https://github.com/angular/angular/issues/9649) [#12675](https://github.com/angular/angular/issues/12675)
-* **upgrade:** enable Angular 1 unit testing of upgrade module ([2fc0560](https://github.com/angular/angular/commit/2fc0560)), closes [#5462](https://github.com/angular/angular/issues/5462) [#12675](https://github.com/angular/angular/issues/12675)
-
-
-### Performance Improvements
-
-* **animations:** always run the animation queue outside of zones ([e2622ad](https://github.com/angular/angular/commit/e2622ad)), closes [#13440](https://github.com/angular/angular/issues/13440)
-
-### Note ###
-
-Due to regression in the 2.3.0 release that was fixed by [#13464](https://github.com/angular/angular/pull/13464), 
-components that have been compiled using 2.3.0 and published to npm will need to be recompiled and republished.
-
-The >=2.3.1 compiler will issue is the following error if it encounters components compiled with 2.3.0:  
-`Unsupported metadata version 2 for module ${module}. This module should be compiled with a newer version of ngc`.
-
-We are adding more tests to our test suite to catch these kinds of problems before we cut a release.
-
-
-<a name="2.3.0"></a>
-# [2.3.0](https://github.com/angular/angular/compare/2.3.0-rc.0...2.3.0) (2016-12-07)
-
-
-### Bug Fixes
-
-* **common:** make sure the plural category exists ([#13169](https://github.com/angular/angular/issues/13169)) ([82c81cd](https://github.com/angular/angular/commit/82c81cd)), closes [#12379](https://github.com/angular/angular/issues/12379)
-* **compiler:** include the summaries of reexported modules / directives / pipes ([#13196](https://github.com/angular/angular/issues/13196)) ([75d1617](https://github.com/angular/angular/commit/75d1617))
-* **compiler:** serialize any `StaticSymbol` correctly, not matter in which context ([5614c4f](https://github.com/angular/angular/commit/5614c4f))
-* **compiler:** short-circut expressions with an index ([#13263](https://github.com/angular/angular/issues/13263)) ([f31c947](https://github.com/angular/angular/commit/f31c947)), closes [#13254](https://github.com/angular/angular/issues/13254)
-* **core:** display framework version on bootstrapped component ([#13252](https://github.com/angular/angular/issues/13252)) ([16efb13](https://github.com/angular/angular/commit/16efb13))
-* **facade:** cache original format string ([#12764](https://github.com/angular/angular/issues/12764)) ([a132287](https://github.com/angular/angular/commit/a132287))
-* **http:** set the default Accept header ([#12989](https://github.com/angular/angular/issues/12989)) ([986abbe](https://github.com/angular/angular/commit/986abbe)), closes [#6354](https://github.com/angular/angular/issues/6354)
-* **language-service:** avoid throwing for invalid class declarations ([#13257](https://github.com/angular/angular/issues/13257)) ([93556a5](https://github.com/angular/angular/commit/93556a5)), closes [#13253](https://github.com/angular/angular/issues/13253)
-* **language-service:** do not throw for invalid metadata ([#13261](https://github.com/angular/angular/issues/13261)) ([4a09c81](https://github.com/angular/angular/commit/4a09c81)), closes [#13255](https://github.com/angular/angular/issues/13255)
-* **language-service:** remove incompletely used parameter from `createLanguageServiceFromTypescript()` ([#13278](https://github.com/angular/angular/issues/13278)) ([25c2141](https://github.com/angular/angular/commit/25c2141)), closes [#13277](https://github.com/angular/angular/issues/13277)
-* **language-service:** update to use `CompilerHost` from compiler-cli ([#13189](https://github.com/angular/angular/issues/13189)) ([3ff6554](https://github.com/angular/angular/commit/3ff6554))
-* **router:** allow specifying a matcher without specifying a path ([bbb7a39](https://github.com/angular/angular/commit/bbb7a39)), closes [#12972](https://github.com/angular/angular/issues/12972)
-* **router:** fix replaceUrl on RouterLink directives ([349ad75](https://github.com/angular/angular/commit/349ad75))
-* **router:** fix skipLocationChanges on RouterLink directives ([f562cbf](https://github.com/angular/angular/commit/f562cbf)), closes [#13156](https://github.com/angular/angular/issues/13156)
-* **router:** make setUpLocationChangeListener idempotent ([25e5b2f](https://github.com/angular/angular/commit/25e5b2f))
-* **router:** runs guards every time when unsuccessfully navigating to the same url over and over again ([#13209](https://github.com/angular/angular/issues/13209)) ([d46b8de](https://github.com/angular/angular/commit/d46b8de))
-* **router:** throw a better error message when angular 1 is not bootstraped ([c767df0](https://github.com/angular/angular/commit/c767df0))
-* **router:** validate nested routes ([#13224](https://github.com/angular/angular/issues/13224)) ([2893c2c](https://github.com/angular/angular/commit/2893c2c)), closes [#12827](https://github.com/angular/angular/issues/12827)
-* **tsc-wrapped:** have UserError display the actual error ([393c100](https://github.com/angular/angular/commit/393c100))
-
-
-### Features
-
-* **compiler:** read and write `.ngsummary.json` files ([614a35d](https://github.com/angular/angular/commit/614a35d)), closes [#12787](https://github.com/angular/angular/issues/12787)
-
-
-
-<a name="2.3.0-rc.0"></a>
-# [2.3.0-rc.0](https://github.com/angular/angular/compare/2.3.0-beta.0...2.3.0-rc.0) (2016-11-30)
-
-
-### Bug Fixes
-
-* **animations:** blend in all previously transitioned styles into next animation if interrupted ([#13014](https://github.com/angular/angular/issues/13014)) ([ef96763](https://github.com/angular/angular/commit/ef96763)), closes [#13013](https://github.com/angular/angular/issues/13013)
-* **benchmarks:** use sanitized style values ([#12943](https://github.com/angular/angular/issues/12943)) ([fc5ac1e](https://github.com/angular/angular/commit/fc5ac1e))
-* **build:** update versions of umd bundles ([#13038](https://github.com/angular/angular/issues/13038)) ([86ffa88](https://github.com/angular/angular/commit/86ffa88)), closes [#13037](https://github.com/angular/angular/issues/13037)
-* **changelog:** replace beta.1 with beta.0 ([#12961](https://github.com/angular/angular/issues/12961)) ([07a986d](https://github.com/angular/angular/commit/07a986d))
-* **ci:** pin version of npm on CircleCI ([#12954](https://github.com/angular/angular/issues/12954)) ([a3884db](https://github.com/angular/angular/commit/a3884db))
-* **closure:** quote date pattern aliases ([#13012](https://github.com/angular/angular/issues/13012)) ([7dcca30](https://github.com/angular/angular/commit/7dcca30))
-* **common:** update DatePipe to allow closure compilation ([b2b7219](https://github.com/angular/angular/commit/b2b7219))
-* **compiler:** correctly evaluate references to static functions ([#13133](https://github.com/angular/angular/issues/13133)) ([627282d](https://github.com/angular/angular/commit/627282d))
-* **compiler:** fix performance regression caused by 5b0f9e2 ([43c0e9a](https://github.com/angular/angular/commit/43c0e9a)), closes [#13146](https://github.com/angular/angular/issues/13146)
-* **compiler:** fix versions of `@angular/tsc-wrapped` ([bccf0e6](https://github.com/angular/angular/commit/bccf0e6))
-* **compiler-cli:** fix paths in source maps to be relative ([2a3ca7b](https://github.com/angular/angular/commit/2a3ca7b)), closes [#13040](https://github.com/angular/angular/issues/13040)
-* **compiler-cli:** pin the version of `tsc-wrapped` ([966bcba](https://github.com/angular/angular/commit/966bcba))
-* **language-service:** harden against partial normalization of directives ([2975d89](https://github.com/angular/angular/commit/2975d89))
-* **core:** shrinkwrap was out of date with packages. ([e45b7ff](https://github.com/angular/angular/commit/e45b7ff))
-* **language-service:** make link check pass ([7194fc2](https://github.com/angular/angular/commit/7194fc2))
-* **router:** guards restore an incorrect url when used with skipLocationChange ([ad20d7d](https://github.com/angular/angular/commit/ad20d7d)), closes [#12825](https://github.com/angular/angular/issues/12825)
-* **router:** support redirects to named outlets ([602522b](https://github.com/angular/angular/commit/602522b)), closes [#12740](https://github.com/angular/angular/issues/12740) [#9921](https://github.com/angular/angular/issues/9921)
-* **tsc-wrapped:** set correct version number ([897555c](https://github.com/angular/angular/commit/897555c))
-* **tsc-wrapped:** still emit version 1 metadata to allow use of new components in old setups ([bc69c74](https://github.com/angular/angular/commit/bc69c74))
-* **upgrade:** call ng1 lifecycle hooks ([#12875](https://github.com/angular/angular/issues/12875)) ([1ef4696](https://github.com/angular/angular/commit/1ef4696))
-* **version:** take all of version string after patch version ([f275f36](https://github.com/angular/angular/commit/f275f36))
-
-
-### Features
-
-* **core:** update RxJS peer dependency to 5.0.0-rc.4 Please see [this gist](https://gist.github.com/robwormald/19dea0c70a6e01aadced6731aed4f9f7) if you depend on the `cache` operator ([2d6a003](https://github.com/angular/angular/commit/2d6a003)), closes [#13125](https://github.com/angular/angular/issues/13125)
-* **core:** upgrade zone.js to v0.7.1 ([c4bbafc](https://github.com/angular/angular/commit/c4bbafc))
-* **build:** record angular version in the dom ([#13164](https://github.com/angular/angular/issues/13164)) ([e628b66](https://github.com/angular/angular/commit/e628b66))
-* **core:** expose destroy() method on ViewRef ([808275a](https://github.com/angular/angular/commit/808275a))
-* **core:** properly support inheritance ([f5c8e09](https://github.com/angular/angular/commit/f5c8e09)), closes [#11606](https://github.com/angular/angular/issues/11606) [#12892](https://github.com/angular/angular/issues/12892)
-* **language-service:** add services to support editors ([#12987](https://github.com/angular/angular/issues/12987)) ([519a324](https://github.com/angular/angular/commit/519a324))
-* **router:** add support for custom route reuse strategies ([42cf06f](https://github.com/angular/angular/commit/42cf06f))
-* **tools:** allow disabling annotation lowering ([c1a62e2](https://github.com/angular/angular/commit/c1a62e2))
-
-
-
 <a name="2.2.4"></a>
 ## [2.2.4](https://github.com/angular/angular/compare/2.2.3...2.2.4) (2016-11-30)
 
@@ -252,7 +19,6 @@ We are adding more tests to our test suite to catch these kinds of problems befo
 * **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)
 
@@ -294,8 +60,6 @@ We are adding more tests to our test suite to catch these kinds of problems befo
 
 Note: The 2.3.0-beta.0 release also contains all the changes present in the 2.2.1 release.
 
-
-
 <a name="2.2.1"></a>
 ## [2.2.1](https://github.com/angular/angular/compare/2.2.0...2.2.1) (2016-11-17)
 
@@ -1117,7 +881,7 @@ prefix using `animate-` must now be preixed using `bind-animate-`.
 * core:
   - `ApplicationRef.dispose` is deprecated. Destroy the module that was
     created during bootstrap instead by calling `NgModuleRef.destroy`.
-  - `ApplicationRef.registerDisposeListener` is deprecated.
+  - `AplicationRef.registerDisposeListener` is deprecated.
     Use the `ngOnDestroy` lifecycle hook for providers or
     `NgModuleRef.onDestroy` instead.
   - `disposePlatform` is deprecated. Use `destroyPlatform` instead.

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 demonstrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demonstrating the problem.
+A minimal reproduce scenario using http://plnkr.co/ allows us to quickly confirm a bug (or point out coding problem) as well as confirm that we are fixing the right problem. If plunker is not a suitable way to demostrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demostrating the problem.
 
 We will be insisting on a minimal reproduce scenario in order to save maintainers time and ultimately be able to fix more bugs. Interestingly, from our experience users often find coding problems themselves while preparing a minimal plunk. We understand that sometimes it might be hard to extract essentials bits of code from a larger code-base but we really need to isolate the problem before we can fix it.
 
@@ -244,7 +244,7 @@ changes to be accepted, the CLA must be signed. It's a quick process, we promise
 [github]: https://github.com/angular/angular
 [gitter]: https://gitter.im/angular/angular
 [individual-cla]: http://code.google.com/legal/individual-cla-v1.0.html
-[js-style-guide]: https://google.github.io/styleguide/jsguide.html
+[js-style-guide]: https://google.github.io/styleguide/javascriptguide.xml
 [jsfiddle]: http://jsfiddle.net
 [plunker]: http://plnkr.co/edit
 [runnable]: http://runnable.com

DEVELOPER.md

@@ -1,6 +1,6 @@
-# Building and Testing Angular
+# Building and Testing Angular 2 for JS
 
-This document describes how to set up your development environment to build and test Angular.
+This document describes how to set up your development environment to build and test Angular 2 JS version. 
 It also explains the basic mechanics of using `git`, `node`, and `npm`.
 
 * [Prerequisite Software](#prerequisite-software)
@@ -74,15 +74,6 @@ use in these instructions.
 *Option 2*: defining a bash alias like `alias nbin='PATH=$(npm bin):$PATH'` as detailed in this
 [Stackoverflow answer](http://stackoverflow.com/questions/9679932/how-to-use-package-installed-locally-in-node-modules/15157360#15157360) and used like this: e.g., `nbin gulp build`.
 
-## Installing Bower Modules
-
-Now run `bower` to install additional dependencies:
-
-```shell
-# Install other Angular project dependencies (bower.json)
-bower install
-```
-
 ## Windows only
 
 In order to create the right symlinks, run **as administrator**:
@@ -133,10 +124,9 @@ If you happen to modify the public API of Angular, API golden files must be upda
 $ gulp public-api:update
 ```
 
-Note: The command `gulp public-api:enforce` fails when the API doesn't match the golden files. Make sure to rebuild
-the project before trying to verify after an API change.
+Note: The command `./test.sh tools` fails when the API doesn't match the golden files.
 
-## <a name="clang-format"></a> Formatting your source code
+## 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.
@@ -147,32 +137,4 @@ You can automatically format your code by running:
 $ gulp format
 ```
 
-## Linting/verifying your source code
 
-You can check that your code is properly formatted and adheres to coding style by running:
-
-``` shell
-$ gulp lint
-```
-
-## Publishing your own personal snapshot build
-
-You may find that your un-merged change needs some validation from external participants.
-Rather than requiring them to pull your Pull Request and build Angular locally, you can
-publish the `*-builds` snapshots just like our Travis build does.
-
-First time, you need to create the github repositories:
-
-``` shell
-$ export TOKEN=[get one from https://github.com/settings/tokens]
-$ CREATE_REPOS=1 ./scripts/publish/publish-build-artifacts.sh [github username]
-```
-
-For subsequent snapshots, just run
-
-``` shell
-$ ./scripts/publish/publish-build-artifacts.sh [github username]
-```
-
-The script will publish the build snapshot to a branch with the same name as your current branch,
-and create it if it doesn't exist.

TRIAGE_AND_LABELS.md

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

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: 'SL', required: false}, e2e: {target: null, required: true}},
+  'iOS10': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
   'WindowsPhone': {unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}}
 };
 
@@ -44,10 +44,10 @@ var customLaunchers = {
   'DartiumWithWebPlatform':
       {base: 'Dartium', flags: ['--enable-experimental-web-platform-features']},
   'ChromeNoSandbox': {base: 'Chrome', flags: ['--no-sandbox']},
-  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '54'},
+  'SL_CHROME': {base: 'SauceLabs', browserName: 'chrome', version: '52'},
   'SL_CHROMEBETA': {base: 'SauceLabs', browserName: 'chrome', version: 'beta'},
   'SL_CHROMEDEV': {base: 'SauceLabs', browserName: 'chrome', version: 'dev'},
-  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '50'},
+  'SL_FIREFOX': {base: 'SauceLabs', browserName: 'firefox', version: '46'},
   'SL_FIREFOXBETA': {base: 'SauceLabs', browserName: 'firefox', version: 'beta'},
   'SL_FIREFOXDEV': {base: 'SauceLabs', browserName: 'firefox', version: 'dev'},
   'SL_SAFARI7': {base: 'SauceLabs', browserName: 'safari', platform: 'OS X 10.9', version: '7.0'},
@@ -96,7 +96,7 @@ var customLaunchers = {
   'BS_IE10': {
     base: 'BrowserStack',
     browser: 'ie',
-    browser_version: '10.1',
+    browser_version: '10.0',
     os: 'Windows',
     os_version: '8'
   },

build.sh

@@ -17,7 +17,6 @@ PACKAGES=(core
   upgrade
   router
   compiler-cli
-  language-service
   benchpress)
 BUILD_ALL=true
 BUNDLE=true
@@ -145,11 +144,6 @@ do
     $TSC -p ${SRCDIR}/tsconfig-testing.json
   fi
 
-  if [[ -e ${SRCDIR}/tsconfig-2015.json ]]; then
-    echo "======      COMPILING ESM: ${TSC} -p ${SRCDIR}/tsconfig-2015.json"
-    ${TSC} -p ${SRCDIR}/tsconfig-2015.json
-  fi
-
   echo "======      TSC 1.8 d.ts compat for ${DESTDIR}   ====="
   # safely strips 'readonly' specifier from d.ts files to make them compatible with tsc 1.8
   if [ "$(uname)" == "Darwin" ]; then
@@ -181,6 +175,7 @@ do
       mv ${UMD_ES5_PATH}.tmp ${UMD_ES5_PATH}
       $UGLIFYJS -c --screw-ie8 --comments -o ${UMD_ES5_MIN_PATH} ${UMD_ES5_PATH}
 
+
       if [[ -e rollup-testing.config.js ]]; then
         echo "======         Rollup ${PACKAGE} testing"
         ../../../node_modules/.bin/rollup -c rollup-testing.config.js

circle.yml

@@ -1,10 +1,10 @@
 machine:
   node:
-    version: 6.6.0
+    version: 5.4.1
 
 dependencies:
   pre:
-    - npm install -g npm@3.5.3
+    - npm install -g npm@3.6.0
 
 test:
   override:

karma-js.conf.js

@@ -24,25 +24,17 @@ module.exports = function(config) {
       'node_modules/core-js/client/core.js',
       // include Angular v1 for upgrade module testing
       'node_modules/angular/angular.js',
-      'node_modules/angular-mocks/angular-mocks.js',
 
-      'node_modules/zone.js/dist/zone.js',
-      'node_modules/zone.js/dist/long-stack-trace-zone.js',
-      'node_modules/zone.js/dist/proxy.js',
-      'node_modules/zone.js/dist/sync-test.js',
-      'node_modules/zone.js/dist/jasmine-patch.js',
-      'node_modules/zone.js/dist/async-test.js',
+      'node_modules/zone.js/dist/zone.js', 'node_modules/zone.js/dist/long-stack-trace-zone.js',
+      'node_modules/zone.js/dist/proxy.js', 'node_modules/zone.js/dist/sync-test.js',
+      'node_modules/zone.js/dist/jasmine-patch.js', 'node_modules/zone.js/dist/async-test.js',
       'node_modules/zone.js/dist/fake-async-test.js',
 
       // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'shims_for_IE.js',
-      'node_modules/systemjs/dist/system.src.js',
+      'shims_for_IE.js', 'node_modules/systemjs/dist/system.src.js',
       {pattern: 'node_modules/rxjs/**', included: false, watched: false, served: true},
-      'node_modules/reflect-metadata/Reflect.js',
-      'tools/build/file2modulename.js',
-      'test-main.js',
-      {pattern: 'dist/all/empty.*', included: false, watched: false},
-      {
+      'node_modules/reflect-metadata/Reflect.js', 'tools/build/file2modulename.js', 'test-main.js',
+      {pattern: 'dist/all/empty.*', included: false, watched: false}, {
         pattern: 'modules/@angular/platform-browser/test/static_assets/**',
         included: false,
         watched: false
@@ -56,15 +48,11 @@ module.exports = function(config) {
 
     exclude: [
       'dist/all/@angular/**/e2e_test/**',
-      '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/examples/**/e2e_test/*',
-      'dist/all/@angular/language-service/**',
       'dist/all/@angular/router/**',
-      'dist/all/@angular/platform-browser/testing/e2e_util.js',
+      'dist/all/@angular/compiler-cli/**',
+      'dist/all/@angular/benchpress/**',
       'dist/all/angular1_router.js',
+      'dist/all/@angular/platform-browser/testing/e2e_util.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.1",
+    "rxjs": "5.0.0-beta.12",
     "jpm": "1.1.4",
     "firefox-profile": "0.4.0",
     "selenium-webdriver": "^2.53.3"

modules/@angular/common/index.ts

@@ -11,6 +11,9 @@
  * @description
  * Entry point for all public APIs of the common package.
  */
-export * from './src/common';
+export * from './src/location';
+export {NgLocalization} from './src/localization';
+export {CommonModule} from './src/common_module';
 
-// This file only reexports content of the `src` folder. Keep it that way.
+export {NgClass, NgFor, NgIf, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet} from './src/directives/index';
+export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe} from './src/pipes/index';

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

@@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * @module
- * @description
- * Entry point for all public APIs of the common package.
- */
-export * from './location/index';
-export {NgLocalization} from './localization';
-export {CommonModule} from './common_module';
-export {NgClass, NgFor, NgIf, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet} from './directives/index';
-export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe} from './pipes/index';
-export {VERSION} from './version';
-export {Version} from '@angular/core';

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

@@ -9,7 +9,7 @@
 import {CollectionChangeRecord, Directive, DoCheck, ElementRef, Input, IterableDiffer, IterableDiffers, KeyValueChangeRecord, KeyValueDiffer, KeyValueDiffers, Renderer} from '@angular/core';
 
 import {isListLikeIterable} from '../facade/collection';
-import {stringify} from '../facade/lang';
+import {isPresent, stringify} from '../facade/lang';
 
 /**
  * @ngModule CommonModule
@@ -25,8 +25,6 @@ import {stringify} from '../facade/lang';
  *     <some-element [ngClass]="{'first': true, 'second': true, 'third': false}">...</some-element>
  *
  *     <some-element [ngClass]="stringExp|arrayExp|objExp">...</some-element>
- *
- *     <some-element [ngClass]="{'class1 class2 class3' : true}">...</some-element>
  * ```
  *
  * @description
@@ -134,7 +132,7 @@ export class NgClass implements DoCheck {
         (<any>rawClassVal).forEach((klass: string) => this._toggleClass(klass, !isCleanup));
       } else {
         Object.keys(rawClassVal).forEach(klass => {
-          if (rawClassVal[klass] != null) this._toggleClass(klass, !isCleanup);
+          if (isPresent(rawClassVal[klass])) this._toggleClass(klass, !isCleanup);
         });
       }
     }

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

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

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

@@ -21,9 +21,10 @@ import {SwitchView} from './ng_switch';
  * @howToUse
  * ```
  * <some-element [ngPlural]="value">
- *   <template ngPluralCase="=0">there is nothing</template>
- *   <template ngPluralCase="=1">there is one</template>
- *   <template ngPluralCase="few">there are a few</template>
+ *   <ng-container *ngPluralCase="'=0'">there is nothing</ng-container>
+ *   <ng-container *ngPluralCase="'=1'">there is one</ng-container>
+ *   <ng-container *ngPluralCase="'few'">there are a few</ng-container>
+ *   <ng-container *ngPluralCase="'other'">there are exactly #</ng-container>
  * </some-element>
  * ```
  *
@@ -89,8 +90,8 @@ export class NgPlural {
  * @howToUse
  * ```
  * <some-element [ngPlural]="value">
- *   <template ngPluralCase="=0">...</template>
- *   <template ngPluralCase="other">...</template>
+ *   <ng-container *ngPluralCase="'=0'">...</ng-container>
+ *   <ng-container *ngPluralCase="'other'">...</ng-container>
  * </some-element>
  *```
  *
@@ -103,7 +104,6 @@ export class NgPluralCase {
   constructor(
       @Attribute('ngPluralCase') public value: string, template: TemplateRef<Object>,
       viewContainer: ViewContainerRef, @Host() ngPlural: NgPlural) {
-    const isANumber: boolean = !isNaN(Number(value));
-    ngPlural.addCase(isANumber ? `=${value}` : value, new SwitchView(viewContainer, template));
+    ngPlural.addCase(value, new SwitchView(viewContainer, template));
   }
 }

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

@@ -23,23 +23,9 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
  */
 export function getPluralCategory(
     value: number, cases: string[], ngLocalization: NgLocalization): string {
-  let key = `=${value}`;
+  const nbCase = `=${value}`;
 
-  if (cases.indexOf(key) > -1) {
-    return key;
-  }
-
-  key = ngLocalization.getPluralCategory(value);
-
-  if (cases.indexOf(key) > -1) {
-    return key;
-  }
-
-  if (cases.indexOf('other') > -1) {
-    return 'other';
-  }
-
-  throw new Error(`No plural message found for value "${value}"`);
+  return cases.indexOf(nbCase) > -1 ? nbCase : ngLocalization.getPluralCategory(value);
 }
 
 /**

modules/@angular/common/src/location.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 './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,8 +17,6 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';
 
 
 /**
- * @whatItDoes Use URL hash for storing application location data.
- * @description
  * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
  * {@link Location} service to represent its state in the
  * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)
@@ -29,7 +27,18 @@ import {LocationChangeListener, PlatformLocation} from './platform_location';
  *
  * ### Example
  *
- * {@example common/location/ts/hash_location_component.ts region='LocationComponent'}
+ * ```
+ * import {Component, NgModule} from '@angular/core';
+ * import {
+ *   LocationStrategy,
+ *   HashLocationStrategy
+ * } from '@angular/common';
+ *
+ * @NgModule({
+ *   providers: [{provide: LocationStrategy, useClass: HashLocationStrategy}]
+ * })
+ * class AppModule {}
+ * ```
  *
  * @stable
  */

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

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

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

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

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

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

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

@@ -7,14 +7,11 @@
  */
 
 import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
-
+import {DateFormatter} from '../facade/intl';
 import {NumberWrapper, isDate} from '../facade/lang';
-
-import {DateFormatter} from './intl';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 
-
 /**
  * @ngModule CommonModule
  * @whatItDoes Formats a date according to locale rules.
@@ -24,7 +21,7 @@ import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
  * Where:
  * - `expression` is a date object or a number (milliseconds since UTC epoch) or an ISO string
  * (https://www.w3.org/TR/NOTE-datetime).
- * - `format` indicates which date/time components to include. The format can be predefined as
+ * - `format` indicates which date/time components to include. The format can be predifined as
  *   shown below or custom as shown in the table.
  *   - `'medium'`: equivalent to `'yMMMdjms'` (e.g. `Sep 3, 2010, 12:05:08 PM` for `en-US`)
  *   - `'short'`: equivalent to `'yMdjm'` (e.g. `9/3/2010, 12:05 PM` for `en-US`)

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

@@ -7,6 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank} from '../facade/lang';
 import {NgLocalization, getPluralCategory} from '../localization';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 
@@ -34,7 +35,7 @@ export class I18nPluralPipe implements PipeTransform {
   constructor(private _localization: NgLocalization) {}
 
   transform(value: number, pluralMap: {[count: string]: string}): string {
-    if (value == null) return '';
+    if (isBlank(value)) return '';
 
     if (typeof pluralMap !== 'object' || pluralMap === null) {
       throw new InvalidPipeArgumentError(I18nPluralPipe, pluralMap);

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

@@ -8,9 +8,9 @@
 
 import {Inject, LOCALE_ID, Pipe, PipeTransform, Type} from '@angular/core';
 
-import {NumberWrapper} from '../facade/lang';
+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+))?)?$/;
@@ -18,7 +18,7 @@ const _NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
 function formatNumber(
     pipe: Type<any>, locale: string, value: number | string, style: NumberFormatStyle,
     digits: string, currency: string = null, currencyAsSymbol: boolean = false): string {
-  if (value == null) return null;
+  if (isBlank(value)) return null;
 
   // Convert strings to numbers
   value = typeof value === 'string' && NumberWrapper.isNumeric(value) ? +value : value;
@@ -41,13 +41,13 @@ function formatNumber(
     if (parts === null) {
       throw new Error(`${digits} is not a valid digit info for number pipes`);
     }
-    if (parts[1] != null) {  // min integer digits
+    if (isPresent(parts[1])) {  // min integer digits
       minInt = NumberWrapper.parseIntAutoRadix(parts[1]);
     }
-    if (parts[3] != null) {  // min fraction digits
+    if (isPresent(parts[3])) {  // min fraction digits
       minFraction = NumberWrapper.parseIntAutoRadix(parts[3]);
     }
-    if (parts[5] != null) {  // max fraction digits
+    if (isPresent(parts[5])) {  // max fraction digits
       maxFraction = NumberWrapper.parseIntAutoRadix(parts[5]);
     }
   }

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

@@ -7,6 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank} from '../facade/lang';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
@@ -57,7 +58,7 @@ import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 @Pipe({name: 'slice', pure: false})
 export class SlicePipe implements PipeTransform {
   transform(value: any, start: number, end?: number): any {
-    if (value == null) return value;
+    if (isBlank(value)) return value;
 
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentError(SlicePipe, value);

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

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

@@ -7,7 +7,7 @@
  */
 
 import {CommonModule} from '@angular/common';
-import {Component} from '@angular/core';
+import {Component, ContentChild, TemplateRef} from '@angular/core';
 import {ComponentFixture, TestBed, async} from '@angular/core/testing';
 import {By} from '@angular/platform-browser/src/dom/debug/by';
 import {expect} from '@angular/platform-browser/testing/matchers';
@@ -29,7 +29,10 @@ export function main() {
 
     beforeEach(() => {
       TestBed.configureTestingModule({
-        declarations: [TestComponent],
+        declarations: [
+          TestComponent,
+          ComponentUsingTestComponent,
+        ],
         imports: [CommonModule],
       });
     });
@@ -74,7 +77,7 @@ export function main() {
        }));
 
     it('should iterate over an array of objects', async(() => {
-         const template = '<ul><li *ngFor="let item of items">{{item["name"]}};</li></ul>';
+         const template = '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
          fixture = createTestComponent(template);
 
          // INIT
@@ -92,7 +95,7 @@ export function main() {
        }));
 
     it('should gracefully handle nulls', async(() => {
-         const template = '<ul><li *ngFor="let item of null">{{item}};</li></ul>';
+         const template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
          fixture = createTestComponent(template);
 
          detectChangesAndExpectText('');
@@ -137,8 +140,12 @@ export function main() {
        }));
 
     it('should repeat over nested arrays', async(() => {
-         const template = '<div *ngFor="let item of items">' +
-             '<div *ngFor="let subitem of item">{{subitem}}-{{item.length}};</div>|' +
+         const template = '<div>' +
+             '<div template="ngFor let item of items">' +
+             '<div template="ngFor let subitem of item">' +
+             '{{subitem}}-{{item.length}};' +
+             '</div>|' +
+             '</div>' +
              '</div>';
          fixture = createTestComponent(template);
 
@@ -150,9 +157,10 @@ export function main() {
        }));
 
     it('should repeat over nested arrays with no intermediate element', async(() => {
-         const template = '<div *ngFor="let item of items">' +
-             '<div *ngFor="let subitem of item">{{subitem}}-{{item.length}};</div>' +
-             '</div>';
+         const template = '<div><template ngFor let-item [ngForOf]="items">' +
+             '<div template="ngFor let subitem of item">' +
+             '{{subitem}}-{{item.length}};' +
+             '</div></template></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [['a', 'b'], ['c']];
@@ -162,11 +170,10 @@ export function main() {
          detectChangesAndExpectText('e-1;f-2;g-2;');
        }));
 
-    it('should repeat over nested ngIf that are the last node in the ngFor template', async(() => {
-         const template = `<div *ngFor="let item of items; let i=index">` +
-             `<div>{{i}}|</div>` +
-             `<div *ngIf="i % 2 == 0">even|</div>` +
-             `</div>`;
+    it('should repeat over nested ngIf that are the last node in the ngFor temlate', async(() => {
+         const template =
+             `<div><template ngFor let-item [ngForOf]="items" let-i="index"><div>{{i}}|</div>` +
+             `<div *ngIf="i % 2 == 0">even|</div></template></div>`;
 
          fixture = createTestComponent(template);
 
@@ -182,7 +189,8 @@ export function main() {
        }));
 
     it('should display indices correctly', async(() => {
-         const template = '<span *ngFor ="let item of items; let i=index">{{i.toString()}}</span>';
+         const template =
+             '<div><span template="ngFor: let item of items; let i=index">{{i.toString()}}</span></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
@@ -194,7 +202,7 @@ export function main() {
 
     it('should display first item correctly', async(() => {
          const template =
-             '<span *ngFor="let item of items; let isFirst=first">{{isFirst.toString()}}</span>';
+             '<div><span template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</span></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -206,7 +214,7 @@ export function main() {
 
     it('should display last item correctly', async(() => {
          const template =
-             '<span *ngFor="let item of items; let isLast=last">{{isLast.toString()}}</span>';
+             '<div><span template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</span></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -218,7 +226,7 @@ export function main() {
 
     it('should display even items correctly', async(() => {
          const template =
-             '<span *ngFor="let item of items; let isEven=even">{{isEven.toString()}}</span>';
+             '<div><span template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</span></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -230,7 +238,7 @@ export function main() {
 
     it('should display odd items correctly', async(() => {
          const template =
-             '<span *ngFor="let item of items; let isOdd=odd">{{isOdd.toString()}}</span>';
+             '<div><span template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</span></div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2, 3];
@@ -241,57 +249,54 @@ export function main() {
        }));
 
     it('should allow to use a custom template', async(() => {
-         const template =
-             '<ng-container *ngFor="let item of items; template: tpl"></ng-container>' +
-             '<template let-item let-i="index" #tpl><p>{{i}}: {{item}};</p></template>';
-         fixture = createTestComponent(template);
-         getComponent().items = ['a', 'b', 'c'];
+         const tcTemplate =
+             '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>';
+         TestBed.overrideComponent(TestComponent, {set: {template: tcTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         fixture = TestBed.createComponent(ComponentUsingTestComponent);
+
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
          fixture.detectChanges();
-         detectChangesAndExpectText('0: a;1: b;2: c;');
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
        }));
 
     it('should use a default template if a custom one is null', async(() => {
-         const template =
-             `<ul><ng-container *ngFor="let item of items; template: null; let i=index">{{i}}: {{item}};</ng-container></ul>`;
-         fixture = createTestComponent(template);
-         getComponent().items = ['a', 'b', 'c'];
+         const testTemplate = `<ul><template ngFor let-item [ngForOf]="items"
+            [ngForTemplate]="contentTpl" let-i="index">{{i}}: {{item}};</template></ul>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: testTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         fixture = TestBed.createComponent(ComponentUsingTestComponent);
+
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
          fixture.detectChanges();
-         detectChangesAndExpectText('0: a;1: b;2: c;');
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
        }));
 
     it('should use a custom template when both default and a custom one are present', async(() => {
-         const template =
-             '<ng-container *ngFor="let item of items; template: tpl">{{i}};</ng-container>' +
-             '<template let-item let-i="index" #tpl>{{i}}: {{item}};</template>';
-         fixture = createTestComponent(template);
-         getComponent().items = ['a', 'b', 'c'];
+         const testTemplate = `<ul><template ngFor let-item [ngForOf]="items"
+         [ngForTemplate]="contentTpl" let-i="index">{{i}}=> {{item}};</template></ul>`;
+         TestBed.overrideComponent(TestComponent, {set: {template: testTemplate}});
+         const cutTemplate =
+             '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>';
+         TestBed.overrideComponent(ComponentUsingTestComponent, {set: {template: cutTemplate}});
+         fixture = TestBed.createComponent(ComponentUsingTestComponent);
+
+         const testComponent = fixture.debugElement.children[0];
+         testComponent.componentInstance.items = ['a', 'b', 'c'];
          fixture.detectChanges();
-         detectChangesAndExpectText('0: a;1: b;2: c;');
+         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
        }));
 
     describe('track by', () => {
-      it('should console.warn if trackBy is not a function', async(() => {
-           // TODO(vicb): expect a warning message when we have a proper log service
-           const template = `<p *ngFor="let item of items; trackBy: value"></p>`;
-           fixture = createTestComponent(template);
-           fixture.componentInstance.value = 0;
-           fixture.detectChanges();
-         }));
-
-      it('should track by identity when trackBy is to `null` or `undefined`', async(() => {
-           // TODO(vicb): expect no warning message when we have a proper log service
-           const template = `<p *ngFor="let item of items; trackBy: value">{{ item }}</p>`;
-           fixture = createTestComponent(template);
-           fixture.componentInstance.items = ['a', 'b', 'c'];
-           fixture.componentInstance.value = null;
-           detectChangesAndExpectText('abc');
-           fixture.componentInstance.value = undefined;
-           detectChangesAndExpectText('abc');
-         }));
-
       it('should set the context to the component instance', async(() => {
            const template =
-               `<p *ngFor="let item of items; trackBy: trackByContext.bind(this)"></p>`;
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
            fixture = createTestComponent(template);
 
            thisArg = null;
@@ -301,7 +306,9 @@ export function main() {
 
       it('should not replace tracked items', async(() => {
            const template =
-               `<p *ngFor="let item of items; trackBy: trackById; let i=index">{{items[i]}}</p>`;
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
+               <p>{{items[i]}}</p>
+              </template>`;
            fixture = createTestComponent(template);
 
            const buildItemList = () => {
@@ -317,7 +324,7 @@ export function main() {
 
       it('should update implicit local variable on view', async(() => {
            const template =
-               `<div *ngFor="let item of items; trackBy: trackById">{{item['color']}}</div>`;
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = [{'id': 'a', 'color': 'blue'}];
@@ -326,10 +333,9 @@ export function main() {
            getComponent().items = [{'id': 'a', 'color': 'red'}];
            detectChangesAndExpectText('red');
          }));
-
       it('should move items around and keep them updated ', async(() => {
            const template =
-               `<div *ngFor="let item of items; trackBy: trackById">{{item['color']}}</div>`;
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = [{'id': 'a', 'color': 'blue'}, {'id': 'b', 'color': 'yellow'}];
@@ -340,7 +346,8 @@ export function main() {
          }));
 
       it('should handle added and removed items properly when tracking by index', async(() => {
-           const template = `<div *ngFor="let item of items; trackBy: trackByIndex">{{item}}</div>`;
+           const template =
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = ['a', 'b', 'c', 'd'];
@@ -360,16 +367,21 @@ class Foo {
 
 @Component({selector: 'test-cmp', template: ''})
 class TestComponent {
-  value: any;
+  @ContentChild(TemplateRef) contentTpl: TemplateRef<Object>;
   items: any[] = [1, 2];
   trackById(index: number, item: any): string { return item['id']; }
   trackByIndex(index: number, item: any): number { return index; }
   trackByContext(): void { thisArg = this; }
 }
 
-const TEMPLATE = '<div><span *ngFor="let item of items">{{item.toString()}};</span></div>';
+@Component({selector: 'outer-cmp', template: ''})
+class ComponentUsingTestComponent {
+  items: any = [1, 2];
+}
+
+const TEMPLATE = '<div><span template="ngFor let item of items">{{item.toString()}};</span></div>';
 
 function createTestComponent(template: string = TEMPLATE): ComponentFixture<TestComponent> {
   return TestBed.overrideComponent(TestComponent, {set: {template: template}})
       .createComponent(TestComponent);
-}
+}

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

@@ -9,7 +9,6 @@
 import {CommonModule} from '@angular/common';
 import {Component} from '@angular/core';
 import {ComponentFixture, TestBed, async} from '@angular/core/testing';
-import {By} from '@angular/platform-browser/src/dom/debug/by';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
@@ -29,114 +28,131 @@ export function main() {
     });
 
     it('should work in a template attribute', async(() => {
-         const template = '<span *ngIf="booleanCondition">hello</span>';
+         const template = '<div><span template="ngIf booleanCondition">hello</span></div>';
          fixture = createTestComponent(template);
+
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
        }));
 
-    it('should work on a template element', async(() => {
-         const template = '<template [ngIf]="booleanCondition">hello2</template>';
+    it('should work in a template element', async(() => {
+         const template =
+             '<div><template [ngIf]="booleanCondition"><span>hello2</span></template></div>';
+
          fixture = createTestComponent(template);
          fixture.detectChanges();
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello2');
        }));
 
     it('should toggle node when condition changes', async(() => {
-         const template = '<span *ngIf="booleanCondition">hello</span>';
+         const template = '<div><span template="ngIf booleanCondition">hello</span></div>';
+
          fixture = createTestComponent(template);
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().booleanCondition = true;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
        }));
 
     it('should handle nested if correctly', async(() => {
          const template =
-             '<div *ngIf="booleanCondition"><span *ngIf="nestedBooleanCondition">hello</span></div>';
+             '<div><template [ngIf]="booleanCondition"><span *ngIf="nestedBooleanCondition">hello</span></template></div>';
 
          fixture = createTestComponent(template);
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().booleanCondition = true;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().nestedBooleanCondition = false;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().nestedBooleanCondition = true;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
        }));
 
     it('should update several nodes with if', async(() => {
-         const template = '<span *ngIf="numberCondition + 1 >= 2">helloNumber</span>' +
-             '<span *ngIf="stringCondition == \'foo\'">helloString</span>' +
-             '<span *ngIf="functionCondition(stringCondition, numberCondition)">helloFunction</span>';
+         const template = '<div>' +
+             '<span template="ngIf numberCondition + 1 >= 2">helloNumber</span>' +
+             '<span template="ngIf stringCondition == \'foo\'">helloString</span>' +
+             '<span template="ngIf functionCondition(stringCondition, numberCondition)">helloFunction</span>' +
+             '</div>';
 
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(3);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(3);
          expect(getDOM().getText(fixture.nativeElement))
              .toEqual('helloNumberhelloStringhelloFunction');
 
          getComponent().numberCondition = 0;
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('helloString');
 
          getComponent().numberCondition = 1;
          getComponent().stringCondition = 'bar';
          fixture.detectChanges();
-         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('helloNumber');
        }));
 
-    it('should not add the element twice if the condition goes from truthy to truthy', async(() => {
-         const template = '<span *ngIf="numberCondition">hello</span>';
+    it('should not add the element twice if the condition goes from true to true (JS)',
+       async(() => {
+         const template = '<div><span template="ngIf numberCondition">hello</span></div>';
 
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
-         let els = fixture.debugElement.queryAll(By.css('span'));
-         expect(els.length).toEqual(1);
-         getDOM().addClass(els[0].nativeElement, 'marker');
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().numberCondition = 2;
          fixture.detectChanges();
-         els = fixture.debugElement.queryAll(By.css('span'));
-         expect(els.length).toEqual(1);
-         expect(getDOM().hasClass(els[0].nativeElement, 'marker')).toBe(true);
-
+         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
        }));
+
+    it('should not recreate the element if the condition goes from true to true (JS)', async(() => {
+         const template = '<div><span template="ngIf numberCondition">hello</span></div>';
+
+         fixture = createTestComponent(template);
+
+         fixture.detectChanges();
+         getDOM().addClass(getDOM().querySelector(fixture.nativeElement, 'span'), 'foo');
+
+         getComponent().numberCondition = 2;
+         fixture.detectChanges();
+         expect(getDOM().hasClass(getDOM().querySelector(fixture.nativeElement, 'span'), 'foo'))
+             .toBe(true);
+       }));
   });
 }
 

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

@@ -12,7 +12,7 @@ import {ComponentFixture, TestBed, async} from '@angular/core/testing';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 export function main() {
-  describe('ngPlural', () => {
+  describe('switch', () => {
     let fixture: ComponentFixture<any>;
 
     function getComponent(): TestComponent { return fixture.componentInstance; }
@@ -33,25 +33,10 @@ export function main() {
     });
 
     it('should display the template according to the exact value', async(() => {
-         const template = '<ul [ngPlural]="switchValue">' +
-             '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
-             '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
-             '</ul>';
-
-         fixture = createTestComponent(template);
-
-         getComponent().switchValue = 0;
-         detectChangesAndExpectText('you have no messages.');
-
-         getComponent().switchValue = 1;
-         detectChangesAndExpectText('you have one message.');
-       }));
-
-    it('should display the template according to the exact numeric value', async(() => {
          const template = '<div>' +
              '<ul [ngPlural]="switchValue">' +
-             '<template ngPluralCase="0"><li>you have no messages.</li></template>' +
-             '<template ngPluralCase="1"><li>you have one message.</li></template>' +
+             '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
+             '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
              '</ul></div>';
 
          fixture = createTestComponent(template);
@@ -66,9 +51,10 @@ export function main() {
     // https://github.com/angular/angular/issues/9868
     // https://github.com/angular/angular/issues/9882
     it('should not throw when ngPluralCase contains expressions', async(() => {
-         const template = '<ul [ngPlural]="switchValue">' +
+         const template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="=0"><li>{{ switchValue }}</li></template>' +
-             '</ul>';
+             '</ul></div>';
 
          fixture = createTestComponent(template);
 
@@ -78,10 +64,11 @@ export function main() {
 
 
     it('should be applicable to <ng-container> elements', async(() => {
-         const template = '<ng-container [ngPlural]="switchValue">' +
+         const template = '<div>' +
+             '<ng-container [ngPlural]="switchValue">' +
              '<template ngPluralCase="=0">you have no messages.</template>' +
              '<template ngPluralCase="=1">you have one message.</template>' +
-             '</ng-container>';
+             '</ng-container></div>';
 
          fixture = createTestComponent(template);
 
@@ -93,10 +80,11 @@ export function main() {
        }));
 
     it('should display the template according to the category', async(() => {
-         const template = '<ul [ngPlural]="switchValue">' +
+         const template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
              '<template ngPluralCase="many"><li>you have many messages.</li></template>' +
-             '</ul>';
+             '</ul></div>';
 
          fixture = createTestComponent(template);
 
@@ -108,10 +96,11 @@ export function main() {
        }));
 
     it('should default to other when no matches are found', async(() => {
-         const template = '<ul [ngPlural]="switchValue">' +
+         const template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
              '<template ngPluralCase="other"><li>default message.</li></template>' +
-             '</ul>';
+             '</ul></div>';
 
          fixture = createTestComponent(template);
 
@@ -120,10 +109,11 @@ export function main() {
        }));
 
     it('should prioritize value matches over category matches', async(() => {
-         const template = '<ul [ngPlural]="switchValue">' +
+         const template = '<div>' +
+             '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
              '<template ngPluralCase="=2">you have two messages.</template>' +
-             '</ul>';
+             '</ul></div>';
 
          fixture = createTestComponent(template);
 

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

@@ -29,19 +29,22 @@ export function main() {
     it('should add styles specified in an object literal', async(() => {
          const template = `<div [ngStyle]="{'max-width': '40px'}"></div>`;
          fixture = createTestComponent(template);
+
          fixture.detectChanges();
          expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
        }));
 
     it('should add and change styles specified in an object expression', async(() => {
          const template = `<div [ngStyle]="expr"></div>`;
+
          fixture = createTestComponent(template);
+         let expr: {[k: string]: string};
 
          getComponent().expr = {'max-width': '40px'};
          fixture.detectChanges();
          expectNativeEl(fixture).toHaveCssStyle({'max-width': '40px'});
 
-         let expr = getComponent().expr;
+         expr = getComponent().expr;
          expr['max-width'] = '30%';
          fixture.detectChanges();
          expectNativeEl(fixture).toHaveCssStyle({'max-width': '30%'});

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

@@ -33,10 +33,11 @@ export function main() {
 
     describe('switch value changes', () => {
       it('should switch amongst when values', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchCase="\'a\'">when a</li>' +
-            '<li *ngSwitchCase="\'b\'">when b</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<template ngSwitchCase="a"><li>when a</li></template>' +
+            '<template ngSwitchCase="b"><li>when b</li></template>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
 
@@ -50,10 +51,11 @@ export function main() {
       });
 
       it('should switch amongst when values with fallback to default', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchCase="\'a\'">when a</li>' +
-            '<li *ngSwitchDefault>when default</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<li template="ngSwitchCase \'a\'">when a</li>' +
+            '<li template="ngSwitchDefault">when default</li>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
         detectChangesAndExpectText('when default');
@@ -69,14 +71,15 @@ export function main() {
       });
 
       it('should support multiple whens with the same value', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchCase="\'a\'">when a1;</li>' +
-            '<li *ngSwitchCase="\'b\'">when b1;</li>' +
-            '<li *ngSwitchCase="\'a\'">when a2;</li>' +
-            '<li *ngSwitchCase="\'b\'">when b2;</li>' +
-            '<li *ngSwitchDefault>when default1;</li>' +
-            '<li *ngSwitchDefault>when default2;</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<template ngSwitchCase="a"><li>when a1;</li></template>' +
+            '<template ngSwitchCase="b"><li>when b1;</li></template>' +
+            '<template ngSwitchCase="a"><li>when a2;</li></template>' +
+            '<template ngSwitchCase="b"><li>when b2;</li></template>' +
+            '<template ngSwitchDefault><li>when default1;</li></template>' +
+            '<template ngSwitchDefault><li>when default2;</li></template>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
         detectChangesAndExpectText('when default1;when default2;');
@@ -91,11 +94,12 @@ export function main() {
 
     describe('when values changes', () => {
       it('should switch amongst when values', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchCase="when1">when 1;</li>' +
-            '<li *ngSwitchCase="when2">when 2;</li>' +
-            '<li *ngSwitchDefault>when default;</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<template [ngSwitchCase]="when1"><li>when 1;</li></template>' +
+            '<template [ngSwitchCase]="when2"><li>when 2;</li></template>' +
+            '<template ngSwitchDefault><li>when default;</li></template>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
         getComponent().when1 = 'a';
@@ -144,10 +148,11 @@ export function main() {
       });
 
       it('should create the default case if there is no other case', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchDefault>when default1;</li>' +
-            '<li *ngSwitchDefault>when default2;</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<template ngSwitchDefault><li>when default1;</li></template>' +
+            '<template ngSwitchDefault><li>when default2;</li></template>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
         detectChangesAndExpectText('when default1;when default2;');
@@ -155,14 +160,15 @@ export function main() {
       });
 
       it('should allow defaults before cases', () => {
-        const template = '<ul [ngSwitch]="switchValue">' +
-            '<li *ngSwitchDefault>when default1;</li>' +
-            '<li *ngSwitchDefault>when default2;</li>' +
-            '<li *ngSwitchCase="\'a\'">when a1;</li>' +
-            '<li *ngSwitchCase="\'b\'">when b1;</li>' +
-            '<li *ngSwitchCase="\'a\'">when a2;</li>' +
-            '<li *ngSwitchCase="\'b\'">when b2;</li>' +
-            '</ul>';
+        const template = '<div>' +
+            '<ul [ngSwitch]="switchValue">' +
+            '<template ngSwitchDefault><li>when default1;</li></template>' +
+            '<template ngSwitchDefault><li>when default2;</li></template>' +
+            '<template ngSwitchCase="a"><li>when a1;</li></template>' +
+            '<template ngSwitchCase="b"><li>when b1;</li></template>' +
+            '<template ngSwitchCase="a"><li>when a2;</li></template>' +
+            '<template ngSwitchCase="b"><li>when b2;</li></template>' +
+            '</ul></div>';
 
         fixture = createTestComponent(template);
         detectChangesAndExpectText('when default1;when default2;');

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

@@ -34,22 +34,29 @@ export function main() {
       });
     });
 
-    it('should do nothing if templateRef is `null`', async(() => {
-         const template = `<ng-container [ngTemplateOutlet]="null"></ng-container>`;
+    it('should do nothing if templateRef is null', async(() => {
+         const template = `<template [ngTemplateOutlet]="null"></template>`;
          fixture = createTestComponent(template);
+
          detectChangesAndExpectText('');
        }));
 
     it('should insert content specified by TemplateRef', async(() => {
-         const template = `<template #tpl>foo</template>` +
-             `<ng-container [ngTemplateOutlet]="tpl"></ng-container>`;
+         const template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          fixture = createTestComponent(template);
+
+         detectChangesAndExpectText('');
+
+         const refs = fixture.debugElement.children[0].references['refs'];
+
+         setTplRef(refs.tplRefs.first);
          detectChangesAndExpectText('foo');
        }));
 
-    it('should clear content if TemplateRef becomes `null`', async(() => {
-         const template = `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs>` +
-             `<ng-container [ngTemplateOutlet]="currentTplRef"></ng-container>`;
+    it('should clear content if TemplateRef becomes null', async(() => {
+         const template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          fixture = createTestComponent(template);
          fixture.detectChanges();
          const refs = fixture.debugElement.children[0].references['refs'];
@@ -63,8 +70,7 @@ export function main() {
 
     it('should swap content if TemplateRef changes', async(() => {
          const template =
-             `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs>` +
-             `<ng-container [ngTemplateOutlet]="currentTplRef"></ng-container>`;
+             `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
@@ -77,47 +83,70 @@ export function main() {
          detectChangesAndExpectText('bar');
        }));
 
-    it('should display template if context is `null`', async(() => {
-         const template = `<template #tpl>foo</template>` +
-             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="null"></ng-container>`;
+    it('should display template if context is null', async(() => {
+         const template =
+             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="null"></template>`;
          fixture = createTestComponent(template);
+         detectChangesAndExpectText('');
+
+         const refs = fixture.debugElement.children[0].references['refs'];
+
+         setTplRef(refs.tplRefs.first);
          detectChangesAndExpectText('foo');
        }));
 
     it('should reflect initial context and changes', async(() => {
-         const template = `<template let-foo="foo" #tpl>{{foo}}</template>` +
-             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="context"></ng-container>`;
+         const template =
+             `<tpl-refs #refs="tplRefs"><template let-foo="foo"><span>{{foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
+
+         const refs = fixture.debugElement.children[0].references['refs'];
+         setTplRef(refs.tplRefs.first);
+
          detectChangesAndExpectText('bar');
 
          fixture.componentInstance.context.foo = 'alter-bar';
+
          detectChangesAndExpectText('alter-bar');
        }));
 
-    it('should reflect user defined `$implicit` property in the context', async(() => {
-         const template = `<template let-ctx #tpl>{{ctx.foo}}</template>` +
-             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="context"></ng-container>`;
+    it('should reflect user defined $implicit property in the context', async(() => {
+         const template =
+             `<tpl-refs #refs="tplRefs"><template let-ctx><span>{{ctx.foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
          fixture = createTestComponent(template);
-         fixture.componentInstance.context = {$implicit: {foo: 'bra'}};
-         detectChangesAndExpectText('bra');
+
+         fixture.detectChanges();
+
+         const refs = fixture.debugElement.children[0].references['refs'];
+         setTplRef(refs.tplRefs.first);
+
+         fixture.componentInstance.context = {$implicit: fixture.componentInstance.context};
+         detectChangesAndExpectText('bar');
        }));
 
     it('should reflect context re-binding', async(() => {
-         const template = `<template let-shawshank="shawshank" #tpl>{{shawshank}}</template>` +
-             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="context"></ng-container>`;
+         const template =
+             `<tpl-refs #refs="tplRefs"><template let-shawshank="shawshank"><span>{{shawshank}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
          fixture = createTestComponent(template);
 
+         fixture.detectChanges();
+
+         const refs = fixture.debugElement.children[0].references['refs'];
+         setTplRef(refs.tplRefs.first);
          fixture.componentInstance.context = {shawshank: 'brooks'};
+
          detectChangesAndExpectText('brooks');
 
          fixture.componentInstance.context = {shawshank: 'was here'};
+
          detectChangesAndExpectText('was here');
        }));
   });
 }
 
+
 @Directive({selector: 'tpl-refs', exportAs: 'tplRefs'})
 class CaptureTplRefs {
   @ContentChildren(TemplateRef) tplRefs: QueryList<TemplateRef<any>>;
@@ -133,4 +162,4 @@ function createTestComponent(template: string): ComponentFixture<TestComponent>
   return TestBed.overrideComponent(TestComponent, {set: {template: template}})
       .configureTestingModule({schemas: [NO_ERRORS_SCHEMA]})
       .createComponent(TestComponent);
-}
+}

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

@@ -7,10 +7,13 @@
  */
 
 import {LOCALE_ID} from '@angular/core';
-import {TestBed, inject} from '@angular/core/testing';
+import {TestBed} from '@angular/core/testing';
+import {beforeEach, describe, inject, it} from '@angular/core/testing/testing_internal';
+import {expect} from '@angular/platform-browser/testing/matchers';
 
 import {NgLocaleLocalization, NgLocalization, getPluralCategory} from '../src/localization';
 
+
 export function main() {
   describe('l10n', () => {
 
@@ -138,23 +141,6 @@ export function main() {
         expect(getPluralCategory(5, ['one', 'other', '=5'], l10n)).toEqual('=5');
         expect(getPluralCategory(6, ['one', 'other', '=5'], l10n)).toEqual('other');
       });
-
-      it('should fallback to other when the case is not present', () => {
-        const l10n = new NgLocaleLocalization('ro');
-        expect(getPluralCategory(1, ['one', 'other'], l10n)).toEqual('one');
-        // 2 -> 'few'
-        expect(getPluralCategory(2, ['one', 'other'], l10n)).toEqual('other');
-      });
-
-      describe('errors', () => {
-        it('should report an error when the "other" category is not present', () => {
-          expect(() => {
-            const l10n = new NgLocaleLocalization('ro');
-            // 2 -> 'few'
-            getPluralCategory(2, ['one'], l10n);
-          }).toThrowError('No plural message found for value "2"');
-        });
-      });
     });
   });
 }

modules/@angular/common/tsconfig-build.json

@@ -22,7 +22,6 @@
     "../../../node_modules/zone.js/dist/zone.js.d.ts"
   ],
   "angularCompilerOptions": {
-    "annotateForClosureCompiler": true,
     "strictMetadataEmit": true
   }
 }

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

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

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

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

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

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

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

@@ -1,32 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {BrowserModule} from '@angular/platform-browser';
-import {RouterModule} from '@angular/router';
-
-import {AppComponent} from './app.component';
-
-@Component({selector: 'home-view', template: 'home!'})
-export class HomeView {
-}
-
-
-@NgModule({
-  declarations: [AppComponent, HomeView],
-  imports: [
-    BrowserModule, RouterModule.forRoot([
-      {path: 'lazy', loadChildren: './lazy.module#LazyModule'},
-      {path: 'feature2', loadChildren: 'feature2/feature2.module#Feature2Module'},
-      {path: '', component: HomeView}
-    ])
-  ],
-  bootstrap: [AppComponent]
-})
-export class AppModule {
-}

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

@@ -1,21 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([{path: '', component: FeatureComponent}])]
-})
-export class FeatureModule {
-}

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

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'lazy-feature-comp', template: 'lazy feature, nested!'})
-export class LazyFeatureNestedComponent {
-}
-
-@NgModule({
-  imports: [RouterModule.forChild([
-    {path: '', component: LazyFeatureNestedComponent, pathMatch: 'full'},
-  ])],
-  declarations: [LazyFeatureNestedComponent]
-})
-export class LazyFeatureNestedModule {
-}

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

@@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'lazy-feature-comp', template: 'lazy feature!'})
-export class LazyFeatureComponent {
-}
-
-@NgModule({
-  imports: [RouterModule.forChild([
-    {path: '', component: LazyFeatureComponent, pathMatch: 'full'},
-    {path: 'feature', loadChildren: './feature.module#FeatureModule'}, {
-      path: 'nested-feature',
-      loadChildren: './lazy-feature-nested.module#LazyFeatureNestedModule'
-    }
-  ])],
-  declarations: [LazyFeatureComponent]
-})
-export class LazyFeatureModule {
-}

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

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([
-    {path: '', component: FeatureComponent},
-  ])]
-})
-export default class DefaultModule {
-}

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

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'feature-component', template: 'foo.html'})
-export class FeatureComponent {
-}
-
-@NgModule({
-  declarations: [FeatureComponent],
-  imports: [RouterModule.forChild([
-    {path: '', component: FeatureComponent}, {path: 'd', loadChildren: './default.module'} {
-      path: 'e',
-      loadChildren: 'feature/feature.module#FeatureModule'
-    }
-  ])]
-})
-export class Feature2Module {
-}

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

@@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Component, NgModule} from '@angular/core';
-import {RouterModule} from '@angular/router';
-
-@Component({selector: 'lazy-comp', template: 'lazy!'})
-export class LazyComponent {
-}
-
-@NgModule({
-  imports: [RouterModule.forChild([
-    {path: '', component: LazyComponent, pathMatch: 'full'},
-    {path: 'feature', loadChildren: './feature/feature.module#FeatureModule'},
-    {path: 'lazy-feature', loadChildren: './feature/lazy-feature.module#LazyFeatureModule'}
-  ])],
-  declarations: [LazyComponent]
-})
-export class LazyModule {
-}
-
-export class SecondModule {}

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

@@ -1,19 +0,0 @@
-{
-  "angularCompilerOptions": {
-    // For TypeScript 1.8, we have to lay out generated files
-    // in the same source directory with your code.
-    "genDir": ".",
-    "debug": true
-  },
-
-  "compilerOptions": {
-    "target": "es5",
-    "experimentalDecorators": true,
-    "noImplicitAny": true,
-    "moduleResolution": "node",
-    "rootDir": "",
-    "declaration": true,
-    "lib": ["es6", "dom"],
-    "baseUrl": "."
-  }
-}

modules/@angular/compiler-cli/integrationtest/src/messages.fi.xtb

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE translationbundle [<!ELEMENT translationbundle (translation)*>
+<!ATTLIST translationbundle lang CDATA #REQUIRED>
+<!ELEMENT translation (#PCDATA|ph)*>
+<!ATTLIST translation id CDATA #REQUIRED>
+<!ELEMENT ph EMPTY>
+<!ATTLIST ph name CDATA #REQUIRED>
+]>
+<translationbundle>
+  <translation id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4">käännä teksti</translation>
+  <translation id="65cc4ab3b4c438e07c89be2b677d08369fb62da2">tervetuloa</translation>
+  <translation id="63a85808f03b8181e36a952e0fa38202c2304862">other-3rdP-component</translation>
+</translationbundle>

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

@@ -11,9 +11,7 @@ import {FormsModule} from '@angular/forms';
 import {ServerModule} from '@angular/platform-server';
 import {MdButtonModule} from '@angular2-material/button';
 
-// Note: don't refer to third_party_src as we want to test that
-// we can compile components from node_modules!
-import {ThirdpartyModule} from 'third_party/module';
+import {ThirdpartyModule} from '../third_party_src/module';
 
 import {MultipleComponentsMyComp, NextComp} from './a/multiple_components';
 import {AnimateCmp} from './animate';
@@ -21,7 +19,7 @@ import {BasicComp} from './basic';
 import {ComponentUsingThirdParty} from './comp_using_3rdp';
 import {CompWithAnalyzeEntryComponentsProvider, CompWithEntryComponents} from './entry_components';
 import {CompConsumingEvents, CompUsingPipes, CompWithProviders, CompWithReferences, DirPublishingEvents, ModuleUsingCustomElements} from './features';
-import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomeLibModule, SomePipeInRootModule, SomeService} from './module_fixtures';
+import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomePipeInRootModule, SomeService, someLibModuleWithProviders} from './module_fixtures';
 import {CompWithNgContent, ProjectingComp} from './projection';
 import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, DirectiveForQuery} from './queries';
 
@@ -54,7 +52,7 @@ import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, Directive
     FormsModule,
     MdButtonModule,
     ModuleUsingCustomElements,
-    SomeLibModule.withProviders(),
+    someLibModuleWithProviders(),
     ThirdpartyModule,
   ],
   providers: [SomeService],

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

@@ -63,13 +63,17 @@ export function provideValueWithEntryComponents(value: any) {
   entryComponents: [CompUsingLibModuleDirectiveAndPipe],
 })
 export class SomeLibModule {
-  static withProviders() {
-    return {
-      ngModule: SomeLibModule,
-      providers: [
-        ServiceUsingLibModule, provideValueWithEntryComponents(
-                                   [{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
-      ]
-    };
-  }
+}
+
+// TODO(tbosch): Make this a static method in `SomeLibModule` once
+// our static reflector supports it.
+// See https://github.com/angular/angular/issues/10266.
+export function someLibModuleWithProviders(): ModuleWithProviders {
+  return {
+    ngModule: SomeLibModule,
+    providers: [
+      ServiceUsingLibModule,
+      provideValueWithEntryComponents([{a: 'b', component: CompUsingLibModuleDirectiveAndPipe}])
+    ]
+  };
 }

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

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

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

@@ -1,217 +0,0 @@
-#!/usr/bin/env node
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/* tslint:disable:no-console  */
-
-// Must be imported first, because angular2 decorators throws on load.
-import 'reflect-metadata';
-
-import * as path from 'path';
-import * as ts from 'typescript';
-import * as assert from 'assert';
-import {tsc} from '@angular/tsc-wrapped/src/tsc';
-import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext, __NGTOOLS_PRIVATE_API_2} from '@angular/compiler-cli';
-
-const glob = require('glob');
-
-/**
- * Main method.
- * Standalone program that executes codegen using the ngtools API and tests that files were
- * properly read and wrote.
- */
-function main() {
-  console.log(`testing ngtools API...`);
-
-  Promise.resolve()
-      .then(() => codeGenTest())
-      .then(() => i18nTest())
-      .then(() => lazyRoutesTest())
-      .then(() => {
-        console.log('All done!');
-        process.exit(0);
-      })
-      .catch((err) => {
-        console.error(err.stack);
-        console.error('Test failed');
-        process.exit(1);
-      });
-}
-
-function codeGenTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = tsc.readConfiguration(project, basePath);
-  const hostContext = new NodeCompilerHostContext();
-  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  console.log(`>>> running codegen for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .codeGen({
-        basePath,
-        compilerOptions: config.parsed.options, program, host,
-
-        angularCompilerOptions: config.ngOptions,
-
-        // i18n options.
-        i18nFormat: null,
-        i18nFile: null,
-        locale: null,
-
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          return hostContext.readResource(fileName);
-        }
-      })
-      .then(() => {
-        console.log(`>>> codegen done, asserting read and wrote files`);
-
-        // Assert for each file that it has been read and each `ts` has a written file associated.
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.module\.ts$/)) {
-            const factory = fileName.replace(/\.module\.ts$/, '.module.ngfactory.ts');
-            assert(wroteFiles.indexOf(factory) != -1, `Expected file "${factory}" to be written.`);
-          } else if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Compilation failed');
-        throw e;
-      });
-}
-
-function i18nTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = tsc.readConfiguration(project, basePath);
-  const hostContext = new NodeCompilerHostContext();
-  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  console.log(`>>> running i18n extraction for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .extractI18n({
-        basePath,
-        compilerOptions: config.parsed.options, program, host,
-        angularCompilerOptions: config.ngOptions,
-        i18nFormat: 'xlf',
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          return hostContext.readResource(fileName);
-        },
-      })
-      .then(() => {
-        console.log(`>>> i18n extraction done, asserting read and wrote files`);
-
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        assert(wroteFiles.length == 1, `Expected a single message bundle file.`);
-
-        assert(
-            wroteFiles[0].endsWith('/ngtools_src/messages.xlf'),
-            `Expected the bundle file to be "message.xlf".`);
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Extraction failed');
-        throw e;
-      });
-}
-
-function lazyRoutesTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-
-  const config = tsc.readConfiguration(project, basePath);
-  const host = ts.createCompilerHost(config.parsed.options, true);
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  const lazyRoutes = __NGTOOLS_PRIVATE_API_2.listLazyRoutes({
-    program,
-    host,
-    angularCompilerOptions: config.ngOptions,
-    entryModule: 'app.module#AppModule'
-  });
-
-  const expectations: {[route: string]: string} = {
-    './lazy.module#LazyModule': 'lazy.module.ts',
-    './feature/feature.module#FeatureModule': 'feature/feature.module.ts',
-    './feature/lazy-feature.module#LazyFeatureModule': 'feature/lazy-feature.module.ts',
-    './feature.module#FeatureModule': 'feature/feature.module.ts',
-    './lazy-feature-nested.module#LazyFeatureNestedModule': 'feature/lazy-feature-nested.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

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/* tslint:disable:no-console  */
-
-// Must be imported first, because angular2 decorators throws on load.
-import 'reflect-metadata';
-
-import * as path from 'path';
-import * as ts from 'typescript';
-import * as assert from 'assert';
-import {tsc} from '@angular/tsc-wrapped/src/tsc';
-import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompilerHostContext} from '@angular/compiler-cli';
-
-/**
- * Main method.
- * Standalone program that executes the real codegen and tests that
- * ngsummary.json files are used for libraries.
- */
-function main() {
-  console.log(`testing usage of ngsummary.json files in libraries...`);
-  const basePath = path.resolve(__dirname, '..');
-  const project = path.resolve(basePath, 'tsconfig-build.json');
-  const readFiles: string[] = [];
-  const writtenFiles: {fileName: string, content: string}[] = [];
-
-  class AssertingHostContext extends NodeCompilerHostContext {
-    readFile(fileName: string): string {
-      if (/.*\/node_modules\/.*/.test(fileName) && !/.*ngsummary\.json$/.test(fileName)) {
-        // Only allow to read summaries from node_modules
-        return null;
-      }
-      readFiles.push(path.relative(basePath, fileName));
-      return super.readFile(fileName);
-    }
-    readResource(s: string): Promise<string> {
-      readFiles.push(path.relative(basePath, s));
-      return super.readResource(s);
-    }
-  }
-
-  const config = tsc.readConfiguration(project, basePath);
-  config.ngOptions.basePath = basePath;
-  // This flag tells ngc do not recompile libraries.
-  config.ngOptions.generateCodeForLibraries = false;
-
-  console.log(`>>> running codegen for ${project}`);
-  codegen(
-      config,
-      (host) => {
-        host.writeFile = (fileName: string, content: string) => {
-          fileName = path.relative(basePath, fileName);
-          writtenFiles.push({fileName, content});
-        };
-        return new AssertingHostContext();
-      })
-      .then((exitCode: any) => {
-        console.log(`>>> codegen done, asserting read files`);
-        assertSomeFileMatch(readFiles, /^node_modules\/.*\.ngsummary\.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.metadata.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.html$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.css$/);
-
-        assertNoFileMatch(readFiles, /^src\/.*\.ngsummary\.json$/);
-        assertSomeFileMatch(readFiles, /^src\/.*\.html$/);
-        assertSomeFileMatch(readFiles, /^src\/.*\.css$/);
-
-        console.log(`>>> asserting written files`);
-        assertWrittenFile(writtenFiles, /^src\/module\.ngfactory\.ts$/, /class MainModuleInjector/);
-
-        console.log(`done, no errors.`);
-        process.exit(exitCode);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Compilation failed');
-        process.exit(1);
-      });
-}
-
-/**
- * Simple adaption of tsc-wrapped main to just run codegen with a CompilerHostContext
- */
-function codegen(
-    config: {parsed: ts.ParsedCommandLine, ngOptions: AngularCompilerOptions},
-    hostContextFactory: (host: ts.CompilerHost) => CompilerHostContext) {
-  const host = ts.createCompilerHost(config.parsed.options, true);
-
-  // HACK: patch the realpath to solve symlink issue here:
-  // https://github.com/Microsoft/TypeScript/issues/9552
-  // todo(misko): remove once facade symlinks are removed
-  host.realpath = (path) => path;
-
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  return CodeGenerator.create(config.ngOptions, {
-                      } as any, program, host, hostContextFactory(host)).codegen();
-}
-
-function assertSomeFileMatch(fileNames: string[], pattern: RegExp) {
-  assert(
-      fileNames.some(fileName => pattern.test(fileName)),
-      `Expected some read files match ${pattern}`);
-}
-
-function assertNoFileMatch(fileNames: string[], pattern: RegExp) {
-  const matches = fileNames.filter(fileName => pattern.test(fileName));
-  assert(
-      matches.length === 0,
-      `Expected no read files match ${pattern}, but found: \n${matches.join('\n')}`);
-}
-
-function assertWrittenFile(
-    files: {fileName: string, content: string}[], filePattern: RegExp, contentPattern: RegExp) {
-  assert(
-      files.some(file => filePattern.test(file.fileName) && contentPattern.test(file.content)),
-      `Expected some written files for ${filePattern} and content ${contentPattern}`);
-}
-
-main();

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

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

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

@@ -14,17 +14,13 @@
     "rootDir": "",
     "declaration": true,
     "lib": ["es6", "dom"],
-    "baseUrl": ".",
-    // Prevent scanning up the directory tree for types
-    "typeRoots": ["node_modules/@types"]
+    "baseUrl": "."
   },
 
   "files": [
     "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.5.1",
+    "@angular/tsc-wrapped": "^0.3.0",
     "reflect-metadata": "^0.1.2",
     "minimist": "^1.2.0"
   },

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

@@ -11,15 +11,20 @@
  * Intended to be used in a build step.
  */
 import * as compiler from '@angular/compiler';
+import {ViewEncapsulation} from '@angular/core';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import {readFileSync} from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+import {PathMappedReflectorHost} from './path_mapped_reflector_host';
+import {Console} from './private_import_core';
+import {ReflectorHost, ReflectorHostContext} from './reflector_host';
+import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
+import {StaticReflector, StaticReflectorHost, StaticSymbol} from './static_reflector';
 
-const GENERATED_META_FILES = /\.json$/;
+const GENERATED_FILES = /\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
+const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
 
 const PREAMBLE = `/**
  * @fileoverview This file is generated by the Angular 2 template compiler.
@@ -33,34 +38,59 @@ const PREAMBLE = `/**
 export class CodeGenerator {
   constructor(
       private options: AngularCompilerOptions, private program: ts.Program,
-      public host: ts.CompilerHost, private compiler: compiler.AotCompiler,
-      private ngCompilerHost: CompilerHost) {}
+      public host: ts.CompilerHost, private staticReflector: StaticReflector,
+      private compiler: compiler.OfflineCompiler, private reflectorHost: StaticReflectorHost) {}
 
-  codegen(): Promise<any> {
-    return this.compiler
-        .compileAll(this.program.getSourceFiles().map(
-            sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)))
-        .then(generatedModules => {
-          generatedModules.forEach(generatedModule => {
-            const sourceFile = this.program.getSourceFile(generatedModule.srcFileUrl);
-            const emitPath = this.ngCompilerHost.calculateEmitPath(generatedModule.genFileUrl);
-            const source = GENERATED_META_FILES.test(emitPath) ? generatedModule.source :
-                                                                 PREAMBLE + generatedModule.source;
-            this.host.writeFile(emitPath, source, false, () => {}, [sourceFile]);
-          });
-        });
+  // Write codegen in a directory structure matching the sources.
+  private calculateEmitPath(filePath: string): string {
+    let root = this.options.basePath;
+    for (const eachRootDir of this.options.rootDirs || []) {
+      if (this.options.trace) {
+        console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
+      }
+      if (path.relative(eachRootDir, filePath).indexOf('.') !== 0) {
+        root = eachRootDir;
+      }
+    }
+
+    // transplant the codegen path to be inside the `genDir`
+    let relativePath: string = path.relative(root, filePath);
+    while (relativePath.startsWith('..' + path.sep)) {
+      // Strip out any `..` path such as: `../node_modules/@foo` as we want to put everything
+      // into `genDir`.
+      relativePath = relativePath.substr(3);
+    }
+
+    return path.join(this.options.genDir, relativePath);
+  }
+
+  codegen(options: {transitiveModules: boolean}): Promise<any> {
+    const staticSymbols =
+        extractProgramSymbols(this.program, this.staticReflector, this.reflectorHost, this.options);
+
+    return this.compiler.compileModules(staticSymbols, options).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]);
+      });
+    });
   }
 
   static create(
       options: AngularCompilerOptions, cliOptions: NgcCliOptions, program: ts.Program,
-      tsCompilerHost: ts.CompilerHost, compilerHostContext?: CompilerHostContext,
-      ngCompilerHost?: CompilerHost): CodeGenerator {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
+      compilerHost: ts.CompilerHost, reflectorHostContext?: ReflectorHostContext,
+      resourceLoader?: compiler.ResourceLoader, reflectorHost?: ReflectorHost): CodeGenerator {
+    resourceLoader = resourceLoader || {
+      get: (s: string) => {
+        if (!compilerHost.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(compilerHost.readFile(s));
+      }
+    };
     const transFile = cliOptions.i18nFile;
     const locale = cliOptions.locale;
     let transContent: string = '';
@@ -71,12 +101,84 @@ export class CodeGenerator {
       }
       transContent = readFileSync(transFile, 'utf8');
     }
-    const {compiler: aotCompiler} = compiler.createAotCompiler(ngCompilerHost, {
-      debug: options.debug === true,
-      translations: transContent,
-      i18nFormat: cliOptions.i18nFormat,
-      locale: cliOptions.locale
+
+    const urlResolver: compiler.UrlResolver = compiler.createOfflineCompileUrlResolver();
+    if (!reflectorHost) {
+      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
+      reflectorHost = usePathMapping ?
+          new PathMappedReflectorHost(program, compilerHost, options, reflectorHostContext) :
+          new ReflectorHost(program, compilerHost, options, reflectorHostContext);
+    }
+    const staticReflector = new StaticReflector(reflectorHost);
+    StaticAndDynamicReflectionCapabilities.install(staticReflector);
+    const htmlParser =
+        new compiler.I18NHtmlParser(new compiler.HtmlParser(), transContent, cliOptions.i18nFormat);
+    const config = new compiler.CompilerConfig({
+      genDebugInfo: options.debug === true,
+      defaultEncapsulation: ViewEncapsulation.Emulated,
+      logBindingUpdate: false,
+      useJit: false
     });
-    return new CodeGenerator(options, program, tsCompilerHost, aotCompiler, ngCompilerHost);
+    const normalizer =
+        new compiler.DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
+    const expressionParser = new compiler.Parser(new compiler.Lexer());
+    const elementSchemaRegistry = new compiler.DomElementSchemaRegistry();
+    const console = new Console();
+    const tmplParser = new compiler.TemplateParser(
+        expressionParser, elementSchemaRegistry, htmlParser, console, []);
+    const resolver = new compiler.CompileMetadataResolver(
+        new compiler.NgModuleResolver(staticReflector),
+        new compiler.DirectiveResolver(staticReflector), new compiler.PipeResolver(staticReflector),
+        elementSchemaRegistry, normalizer, staticReflector);
+    // TODO(vicb): do not pass cliOptions.i18nFormat here
+    const offlineCompiler = new compiler.OfflineCompiler(
+        resolver, tmplParser, new compiler.StyleCompiler(urlResolver),
+        new compiler.ViewCompiler(config, elementSchemaRegistry),
+        new compiler.DirectiveWrapperCompiler(
+            config, expressionParser, elementSchemaRegistry, console),
+        new compiler.NgModuleCompiler(), new compiler.TypeScriptEmitter(reflectorHost),
+        cliOptions.locale, cliOptions.i18nFormat,
+        new compiler.AnimationParser(elementSchemaRegistry));
+
+    return new CodeGenerator(
+        options, program, compilerHost, staticReflector, offlineCompiler, reflectorHost);
   }
 }
+
+export function extractProgramSymbols(
+    program: ts.Program, staticReflector: StaticReflector, reflectorHost: StaticReflectorHost,
+    options: AngularCompilerOptions): StaticSymbol[] {
+  // Compare with false since the default should be true
+  const skipFileNames =
+      options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
+
+  const staticSymbols: StaticSymbol[] = [];
+
+  program.getSourceFiles()
+      .filter(sourceFile => !skipFileNames.test(sourceFile.fileName))
+      .forEach(sourceFile => {
+        const absSrcPath = reflectorHost.getCanonicalFileName(sourceFile.fileName);
+
+        const moduleMetadata = staticReflector.getModuleMetadata(absSrcPath);
+        if (!moduleMetadata) {
+          console.warn(`WARNING: no metadata found for ${absSrcPath}`);
+          return;
+        }
+
+        const metadata = moduleMetadata['metadata'];
+
+        if (!metadata) {
+          return;
+        }
+
+        for (const symbol of Object.keys(metadata)) {
+          if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
+            // Ignore symbols that are only included to record error information.
+            continue;
+          }
+          staticSymbols.push(reflectorHost.findDeclaration(absSrcPath, symbol, absSrcPath));
+        }
+      });
+
+  return staticSymbols;
+}

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

@@ -1,344 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {AotCompilerHost, StaticSymbol} from '@angular/compiler';
-import {AngularCompilerOptions, MetadataCollector, ModuleMetadata} from '@angular/tsc-wrapped';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-const DTS = /\.d\.ts$/;
-const NODE_MODULES = '/node_modules/';
-const IS_GENERATED = /\.(ngfactory|ngstyle)$/;
-const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
-const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;
-
-export interface CompilerHostContext extends ts.ModuleResolutionHost {
-  readResource(fileName: string): Promise<string>;
-  assumeFileExists(fileName: string): void;
-}
-
-export class CompilerHost implements AotCompilerHost {
-  protected metadataCollector = new MetadataCollector();
-  private isGenDirChildOfRootDir: boolean;
-  protected basePath: string;
-  private genDir: string;
-  private resolverCache = new Map<string, ModuleMetadata[]>();
-  protected resolveModuleNameHost: CompilerHostContext;
-
-  constructor(
-      protected program: ts.Program, protected options: AngularCompilerOptions,
-      protected context: CompilerHostContext) {
-    // 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, '/');
-
-    const genPath: string = path.relative(this.basePath, this.genDir);
-    this.isGenDirChildOfRootDir = genPath === '' || !genPath.startsWith('..');
-    this.resolveModuleNameHost = Object.create(this.context);
-
-    // When calling ts.resolveModuleName,
-    // additional allow checks for .d.ts files to be done based on
-    // checks for .ngsummary.json files,
-    // so that our codegen depends on fewer inputs and requires to be called
-    // less often.
-    // This is needed as we use ts.resolveModuleName in reflector_host
-    // and it should be able to resolve summary file names.
-    this.resolveModuleNameHost.fileExists = (fileName: string): boolean => {
-      if (this.context.fileExists(fileName)) {
-        return true;
-      }
-      if (DTS.test(fileName)) {
-        const base = fileName.substring(0, fileName.length - 5);
-        return this.context.fileExists(base + '.ngsummary.json');
-      }
-      return false;
-    };
-  }
-
-  // We use absolute paths on disk as canonical.
-  getCanonicalFileName(fileName: string): string { return fileName; }
-
-  moduleNameToFileName(m: string, containingFile: string): string|null {
-    if (!containingFile || !containingFile.length) {
-      if (m.indexOf('.') === 0) {
-        throw new Error('Resolution of relative paths requires a containing file.');
-      }
-      // Any containing file gives the same result for absolute imports
-      containingFile = this.getCanonicalFileName(path.join(this.basePath, 'index.ts'));
-    }
-    m = m.replace(EXT, '');
-    const resolved =
-        ts.resolveModuleName(
-              m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
-            .resolvedModule;
-    return resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : null;
-  };
-
-  /**
-   * We want a moduleId that will appear in import statements in the generated code.
-   * These need to be in a form that system.js can load, so absolute file paths don't work.
-   *
-   * The `containingFile` is always in the `genDir`, where as the `importedFile` can be in
-   * `genDir`, `node_module` or `basePath`.  The `importedFile` is either a generated file or
-   * existing file.
-   *
-   *               | genDir   | node_module |  rootDir
-   * --------------+----------+-------------+----------
-   * generated     | relative |   relative  |   n/a
-   * existing file |   n/a    |   absolute  |  relative(*)
-   *
-   * NOTE: (*) the relative path is computed depending on `isGenDirChildOfRootDir`.
-   */
-  fileNameToModuleName(importedFile: string, containingFile: string): string {
-    // If a file does not yet exist (because we compile it later), we still need to
-    // assume it exists it so that the `resolve` method works!
-    if (!this.context.fileExists(importedFile)) {
-      this.context.assumeFileExists(importedFile);
-    }
-
-    containingFile = this.rewriteGenDirPath(containingFile);
-    const containingDir = path.dirname(containingFile);
-    // drop extension
-    importedFile = importedFile.replace(EXT, '');
-
-    const nodeModulesIndex = importedFile.indexOf(NODE_MODULES);
-    const importModule = nodeModulesIndex === -1 ?
-        null :
-        importedFile.substring(nodeModulesIndex + NODE_MODULES.length);
-    const isGeneratedFile = IS_GENERATED.test(importedFile);
-
-    if (isGeneratedFile) {
-      // rewrite to genDir path
-      if (importModule) {
-        // it is generated, therefore we do a relative path to the factory
-        return this.dotRelative(containingDir, this.genDir + NODE_MODULES + importModule);
-      } else {
-        // assume that import is also in `genDir`
-        importedFile = this.rewriteGenDirPath(importedFile);
-        return this.dotRelative(containingDir, importedFile);
-      }
-    } else {
-      // user code import
-      if (importModule) {
-        return importModule;
-      } else {
-        if (!this.isGenDirChildOfRootDir) {
-          // assume that they are on top of each other.
-          importedFile = importedFile.replace(this.basePath, this.genDir);
-        }
-        return this.dotRelative(containingDir, importedFile);
-      }
-    }
-  }
-
-  private dotRelative(from: string, to: string): string {
-    const rPath: string = path.relative(from, to).replace(/\\/g, '/');
-    return rPath.startsWith('.') ? rPath : './' + rPath;
-  }
-
-  /**
-   * Moves the path into `genDir` folder while preserving the `node_modules` directory.
-   */
-  private rewriteGenDirPath(filepath: string) {
-    const nodeModulesIndex = filepath.indexOf(NODE_MODULES);
-    if (nodeModulesIndex !== -1) {
-      // If we are in node_modulse, transplant them into `genDir`.
-      return path.join(this.genDir, filepath.substring(nodeModulesIndex));
-    } else {
-      // pretend that containing file is on top of the `genDir` to normalize the paths.
-      // we apply the `genDir` => `rootDir` delta through `rootDirPrefix` later.
-      return filepath.replace(this.basePath, this.genDir);
-    }
-  }
-
-  protected getSourceFile(filePath: string): ts.SourceFile {
-    const sf = this.program.getSourceFile(filePath);
-    if (!sf) {
-      if (this.context.fileExists(filePath)) {
-        const sourceText = this.context.readFile(filePath);
-        return ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
-      }
-      throw new Error(`Source file ${filePath} not present in program.`);
-    }
-    return sf;
-  }
-
-  getMetadataFor(filePath: string): ModuleMetadata[] {
-    if (!this.context.fileExists(filePath)) {
-      // 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).
-      return;
-    }
-    if (DTS.test(filePath)) {
-      const metadataPath = filePath.replace(DTS, '.metadata.json');
-      if (this.context.fileExists(metadataPath)) {
-        return this.readMetadata(metadataPath, filePath);
-      } else {
-        // If there is a .d.ts file but no metadata file we need to produce a
-        // v3 metadata from the .d.ts file as v3 includes the exports we need
-        // to resolve symbols.
-        return [this.upgradeVersion1Metadata(
-            {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
-      }
-    } else {
-      const sf = this.getSourceFile(filePath);
-      const metadata = this.metadataCollector.getMetadata(sf);
-      return metadata ? [metadata] : [];
-    }
-  }
-
-  readMetadata(filePath: string, dtsFilePath: string): ModuleMetadata[] {
-    let metadatas = this.resolverCache.get(filePath);
-    if (metadatas) {
-      return metadatas;
-    }
-    try {
-      const metadataOrMetadatas = JSON.parse(this.context.readFile(filePath));
-      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
-          (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
-          [];
-      const v1Metadata = metadatas.find(m => m.version === 1);
-      let v3Metadata = metadatas.find(m => m.version === 3);
-      if (!v3Metadata && v1Metadata) {
-        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
-      }
-      this.resolverCache.set(filePath, metadatas);
-      return metadatas;
-    } catch (e) {
-      console.error(`Failed to read JSON file ${filePath}`);
-      throw e;
-    }
-  }
-
-  private upgradeVersion1Metadata(v1Metadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
-    // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
-    // as the only difference between the versions is whether all exports are contained in
-    // the metadata and the `extends` clause.
-    let v3Metadata: ModuleMetadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
-    if (v1Metadata.exports) {
-      v3Metadata.exports = v1Metadata.exports;
-    }
-    for (let prop in v1Metadata.metadata) {
-      v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
-    }
-
-    const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
-    if (exports) {
-      for (let prop in exports.metadata) {
-        if (!v3Metadata.metadata[prop]) {
-          v3Metadata.metadata[prop] = exports.metadata[prop];
-        }
-      }
-      if (exports.exports) {
-        v3Metadata.exports = exports.exports;
-      }
-    }
-    return v3Metadata;
-  }
-
-  loadResource(filePath: string): Promise<string> { return this.context.readResource(filePath); }
-
-  loadSummary(filePath: string): string|null {
-    if (this.context.fileExists(filePath)) {
-      return this.context.readFile(filePath);
-    }
-  }
-
-  getOutputFileName(sourceFilePath: string): string {
-    return sourceFilePath.replace(EXT, '') + '.d.ts';
-  }
-
-  isSourceFile(filePath: string): boolean {
-    const excludeRegex =
-        this.options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
-    return !excludeRegex.test(filePath);
-  }
-
-  calculateEmitPath(filePath: string): string {
-    // Write codegen in a directory structure matching the sources.
-    let root = this.options.basePath;
-    for (const eachRootDir of this.options.rootDirs || []) {
-      if (this.options.trace) {
-        console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
-      }
-      if (path.relative(eachRootDir, filePath).indexOf('.') !== 0) {
-        root = eachRootDir;
-      }
-    }
-
-    // transplant the codegen path to be inside the `genDir`
-    let relativePath: string = path.relative(root, filePath);
-    while (relativePath.startsWith('..' + path.sep)) {
-      // Strip out any `..` path such as: `../node_modules/@foo` as we want to put everything
-      // into `genDir`.
-      relativePath = relativePath.substr(3);
-    }
-
-    return path.join(this.options.genDir, relativePath);
-  }
-}
-
-export class CompilerHostContextAdapter {
-  protected 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();
-    } catch (e) {
-      return false;
-    }
-  }
-
-  readFile(fileName: string): string { return fs.readFileSync(fileName, 'utf8'); }
-
-  readResource(s: string) {
-    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.readFile(s));
-  }
-}

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

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

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

@@ -14,75 +14,86 @@
 import 'reflect-metadata';
 
 import * as compiler from '@angular/compiler';
+import {ViewEncapsulation} from '@angular/core';
 import * as tsc from '@angular/tsc-wrapped';
-import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+import {extractProgramSymbols} from './codegen';
+import {ReflectorHost} from './reflector_host';
+import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
+import {StaticReflector, StaticSymbol} from './static_reflector';
 
 export class Extractor {
   constructor(
-      private options: tsc.AngularCompilerOptions, private ngExtractor: compiler.Extractor,
-      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
-      private program: ts.Program) {}
+      private options: tsc.AngularCompilerOptions, private program: ts.Program,
+      public host: ts.CompilerHost, private staticReflector: StaticReflector,
+      private messageBundle: compiler.MessageBundle, private reflectorHost: ReflectorHost,
+      private metadataResolver: compiler.CompileMetadataResolver) {}
 
-  extract(formatName: string): Promise<void> {
-    // Checks the format and returns the extension
-    const ext = this.getExtension(formatName);
+  extract(): Promise<compiler.MessageBundle> {
+    const programSymbols: StaticSymbol[] =
+        extractProgramSymbols(this.program, this.staticReflector, this.reflectorHost, this.options);
 
-    const promiseBundle = this.extractBundle();
+    const {ngModules, files} = compiler.analyzeAndValidateNgModules(
+        programSymbols, {transitiveModules: true}, this.metadataResolver);
+    return compiler.loadNgModuleDirectives(ngModules).then(() => {
+      const errors: compiler.ParseError[] = [];
 
-    return promiseBundle.then(bundle => {
-      const content = this.serialize(bundle, ext);
-      const dstPath = path.join(this.options.genDir, `messages.${ext}`);
-      this.host.writeFile(dstPath, content, false);
+      files.forEach(file => {
+        const compMetas: compiler.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 =
+              compiler.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;
     });
   }
 
-  extractBundle(): Promise<compiler.MessageBundle> {
-    const files = this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName));
-
-    return this.ngExtractor.extract(files);
-  }
-
-  serialize(bundle: compiler.MessageBundle, ext: string): string {
-    let serializer: compiler.Serializer;
-
-    switch (ext) {
-      case 'xmb':
-        serializer = new compiler.Xmb();
-        break;
-      case 'xlf':
-      default:
-        serializer = new compiler.Xliff();
-    }
-
-    return bundle.write(serializer);
-  }
-
-  getExtension(formatName: string): string {
-    const format = (formatName || 'xlf').toLowerCase();
-
-    if (format === 'xmb') return 'xmb';
-    if (format === 'xlf' || format === 'xlif') return 'xlf';
-
-    throw new Error('Unsupported format "${formatName}"');
-  }
-
   static create(
-      options: tsc.AngularCompilerOptions, program: ts.Program, tsCompilerHost: ts.CompilerHost,
-      compilerHostContext?: CompilerHostContext, ngCompilerHost?: CompilerHost): Extractor {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
+      options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
+      compilerHost: ts.CompilerHost, resourceLoader: compiler.ResourceLoader,
+      reflectorHost?: ReflectorHost): Extractor {
+    const htmlParser = new compiler.I18NHtmlParser(new compiler.HtmlParser());
 
-    const {extractor: ngExtractor} = compiler.Extractor.create(ngCompilerHost);
+    const urlResolver: compiler.UrlResolver = compiler.createOfflineCompileUrlResolver();
+    if (!reflectorHost) reflectorHost = new ReflectorHost(program, compilerHost, options);
+    const staticReflector = new StaticReflector(reflectorHost);
+    StaticAndDynamicReflectionCapabilities.install(staticReflector);
 
-    return new Extractor(options, ngExtractor, tsCompilerHost, ngCompilerHost, program);
+    const config = new compiler.CompilerConfig({
+      genDebugInfo: options.debug === true,
+      defaultEncapsulation: ViewEncapsulation.Emulated,
+      logBindingUpdate: false,
+      useJit: false
+    });
+
+    const normalizer =
+        new compiler.DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
+    const elementSchemaRegistry = new compiler.DomElementSchemaRegistry();
+    const resolver = new compiler.CompileMetadataResolver(
+        new compiler.NgModuleResolver(staticReflector),
+        new compiler.DirectiveResolver(staticReflector), new compiler.PipeResolver(staticReflector),
+        elementSchemaRegistry, normalizer, staticReflector);
+
+    // TODO(vicb): implicit tags & attributes
+    const messageBundle = new compiler.MessageBundle(htmlParser, [], {});
+
+    return new Extractor(
+        options, program, compilerHost, staticReflector, messageBundle, reflectorHost, resolver);
   }
-}
+}

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

@@ -14,34 +14,24 @@ import 'reflect-metadata';
 import * as ts from 'typescript';
 import * as tsc from '@angular/tsc-wrapped';
 
-import {SyntaxError} from '@angular/compiler';
 import {CodeGenerator} from './codegen';
 
 function codegen(
     ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.NgcCliOptions, program: ts.Program,
     host: ts.CompilerHost) {
-  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen();
-}
-
-export function main(
-    args: any, consoleError: (s: string) => void = console.error): Promise<number> {
-  const project = args.p || args.project || '.';
-  const cliOptions = new tsc.NgcCliOptions(args);
-
-  return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
-    if (e instanceof tsc.UserError || e instanceof SyntaxError) {
-      consoleError(e.message);
-      return Promise.resolve(1);
-    } else {
-      consoleError(e.stack);
-      consoleError('Compilation failed');
-      return Promise.resolve(1);
-    }
+  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen({
+    transitiveModules: true
   });
 }
 
 // CLI entry point
 if (require.main === module) {
   const args = require('minimist')(process.argv.slice(2));
-  main(args).then((exitCode: number) => process.exit(exitCode));
+  const project = args.p || args.project || '.';
+  const cliOptions = new tsc.NgcCliOptions(args);
+  tsc.main(project, cliOptions, codegen).then(exitCode => process.exit(exitCode)).catch(e => {
+    console.error(e.stack);
+    console.error('Compilation failed');
+    process.exit(1);
+  });
 }

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

@@ -1,150 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * This is a private API for the ngtools toolkit.
- *
- * This API should be stable for NG 2. It can be removed in NG 4..., but should be replaced by
- * something else.
- */
-
-import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
-import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
-import * as ts from 'typescript';
-
-import {CodeGenerator} from './codegen';
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {Extractor} from './extractor';
-import {listLazyRoutesOfModule} from './ngtools_impl';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-
-export interface NgTools_InternalApi_NG2_CodeGen_Options {
-  basePath: string;
-  compilerOptions: ts.CompilerOptions;
-  program: ts.Program;
-  host: ts.CompilerHost;
-
-  angularCompilerOptions: AngularCompilerOptions;
-
-  // i18n options.
-  i18nFormat: string;
-  i18nFile: string;
-  locale: string;
-
-  readResource: (fileName: string) => Promise<string>;
-
-  // Every new property under this line should be optional.
-}
-
-export interface NgTools_InternalApi_NG2_ListLazyRoutes_Options {
-  program: ts.Program;
-  host: ts.CompilerHost;
-  angularCompilerOptions: AngularCompilerOptions;
-  entryModule: string;
-
-  // Every new property under this line should be optional.
-}
-
-export interface NgTools_InternalApi_NG_2_LazyRouteMap { [route: string]: string; }
-
-export interface NgTools_InternalApi_NG2_ExtractI18n_Options {
-  basePath: string;
-  compilerOptions: ts.CompilerOptions;
-  program: ts.Program;
-  host: ts.CompilerHost;
-  angularCompilerOptions: AngularCompilerOptions;
-  i18nFormat: string;
-  readResource: (fileName: string) => Promise<string>;
-  // Every new property under this line should be optional.
-}
-
-/**
- * A ModuleResolutionHostAdapter that overrides the readResource() method with the one
- * passed in the interface.
- */
-class CustomLoaderModuleResolutionHostAdapter extends ModuleResolutionHostAdapter {
-  constructor(
-      private _readResource: (path: string) => Promise<string>, host: ts.ModuleResolutionHost) {
-    super(host);
-  }
-
-  readResource(path: string) { return this._readResource(path); }
-}
-
-
-/**
- * @internal
- * @private
- */
-export class NgTools_InternalApi_NG_2 {
-  /**
-   * @internal
-   * @private
-   */
-  static codeGen(options: NgTools_InternalApi_NG2_CodeGen_Options): Promise<void> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-    const cliOptions: NgcCliOptions = {
-      i18nFormat: options.i18nFormat,
-      i18nFile: options.i18nFile,
-      locale: options.locale,
-      basePath: options.basePath
-    };
-
-    // Create the Code Generator.
-    const codeGenerator = CodeGenerator.create(
-        options.angularCompilerOptions, cliOptions, options.program, options.host, hostContext);
-
-    return codeGenerator.codegen();
-  }
-
-  /**
-   * @internal
-   * @private
-   */
-  static listLazyRoutes(options: NgTools_InternalApi_NG2_ListLazyRoutes_Options):
-      NgTools_InternalApi_NG_2_LazyRouteMap {
-    const angularCompilerOptions = options.angularCompilerOptions;
-    const program = options.program;
-
-    const moduleResolutionHost = new ModuleResolutionHostAdapter(options.host);
-    const usePathMapping =
-        !!angularCompilerOptions.rootDirs && angularCompilerOptions.rootDirs.length > 0;
-    const ngCompilerHost: AotCompilerHost = usePathMapping ?
-        new PathMappedCompilerHost(program, angularCompilerOptions, moduleResolutionHost) :
-        new CompilerHost(program, angularCompilerOptions, moduleResolutionHost);
-
-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
-    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(symbolResolver);
-    const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
-
-    return Object.keys(routeMap).reduce(
-        (acc: NgTools_InternalApi_NG_2_LazyRouteMap, route: string) => {
-          acc[route] = routeMap[route].absoluteFilePath;
-          return acc;
-        },
-        {});
-  }
-
-  /**
-   * @internal
-   * @private
-   */
-  static extractI18n(options: NgTools_InternalApi_NG2_ExtractI18n_Options): Promise<void> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-
-    // Create the i18n extractor.
-    const extractor = Extractor.create(
-        options.angularCompilerOptions, options.program, options.host, hostContext);
-
-    return extractor.extract(options.i18nFormat);
-  }
-}

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

@@ -1,211 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * This is a private API for the ngtools toolkit.
- *
- * This API should be stable for NG 2. It can be removed in NG 4..., but should be replaced by
- * something else.
- */
-import {AotCompilerHost, StaticReflector, StaticSymbol} from '@angular/compiler';
-import {NgModule} from '@angular/core';
-
-// We cannot depend directly to @angular/router.
-type Route = any;
-const ROUTER_MODULE_PATH = '@angular/router/src/router_config_loader';
-const ROUTER_ROUTES_SYMBOL_NAME = 'ROUTES';
-
-
-// LazyRoute information between the extractors.
-export interface LazyRoute {
-  routeDef: RouteDef;
-  absoluteFilePath: string;
-}
-export type LazyRouteMap = {
-  [route: string]: LazyRoute
-};
-
-// A route definition. Normally the short form 'path/to/module#ModuleClassName' is used by
-// the user, and this is a helper class to extract information from it.
-export class RouteDef {
-  private constructor(public readonly path: string, public readonly className: string = null) {}
-
-  toString() {
-    return (this.className === null || this.className == 'default') ?
-        this.path :
-        `${this.path}#${this.className}`;
-  }
-
-  static fromString(entry: string): RouteDef {
-    const split = entry.split('#');
-    return new RouteDef(split[0], split[1] || null);
-  }
-}
-
-
-/**
- *
- * @returns {LazyRouteMap}
- * @private
- */
-export function listLazyRoutesOfModule(
-    entryModule: string, host: AotCompilerHost, reflector: StaticReflector): LazyRouteMap {
-  const entryRouteDef = RouteDef.fromString(entryModule);
-  const containingFile = _resolveModule(entryRouteDef.path, entryRouteDef.path, host);
-  const modulePath = `./${containingFile.replace(/^(.*)\//, '')}`;
-  const className = entryRouteDef.className;
-
-  // List loadChildren of this single module.
-  const appStaticSymbol = reflector.findDeclaration(modulePath, className, containingFile);
-  const ROUTES = reflector.findDeclaration(ROUTER_MODULE_PATH, ROUTER_ROUTES_SYMBOL_NAME);
-  const lazyRoutes: LazyRoute[] =
-      _extractLazyRoutesFromStaticModule(appStaticSymbol, reflector, host, ROUTES);
-
-  const allLazyRoutes = lazyRoutes.reduce(
-      function includeLazyRouteAndSubRoutes(allRoutes: LazyRouteMap, lazyRoute: LazyRoute):
-          LazyRouteMap {
-            const route: string = lazyRoute.routeDef.toString();
-            _assertRoute(allRoutes, lazyRoute);
-            allRoutes[route] = lazyRoute;
-
-            // StaticReflector does not support discovering annotations like `NgModule` on default
-            // exports
-            // Which means: if a default export NgModule was lazy-loaded, we can discover it, but,
-            //  we cannot parse its routes to see if they have loadChildren or not.
-            if (!lazyRoute.routeDef.className) {
-              return allRoutes;
-            }
-
-            const lazyModuleSymbol = reflector.findDeclaration(
-                lazyRoute.absoluteFilePath, lazyRoute.routeDef.className || 'default');
-
-            const subRoutes =
-                _extractLazyRoutesFromStaticModule(lazyModuleSymbol, reflector, host, ROUTES);
-
-            return subRoutes.reduce(includeLazyRouteAndSubRoutes, allRoutes);
-          },
-      {});
-
-  return allLazyRoutes;
-}
-
-
-/**
- * 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 && typeof r.loadChildren === 'string') {
-      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_reflector_host.ts

@@ -6,27 +6,29 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticSymbol} from '@angular/compiler';
 import {AngularCompilerOptions, ModuleMetadata} from '@angular/tsc-wrapped';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost, CompilerHostContext} from './compiler_host';
+import {ReflectorHost, ReflectorHostContext} from './reflector_host';
+import {StaticSymbol} from './static_reflector';
 
 const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 const DTS = /\.d\.ts$/;
 
 /**
- * This version of the AotCompilerHost expects that the program will be compiled
+ * This version of the reflector host expects that the program will be compiled
  * and executed with a "path mapped" directory structure, where generated files
  * are in a parallel tree with the sources, and imported using a `./` relative
  * import. This requires using TS `rootDirs` option and also teaching the module
  * loader what to do.
  */
-export class PathMappedCompilerHost extends CompilerHost {
-  constructor(program: ts.Program, options: AngularCompilerOptions, context: CompilerHostContext) {
-    super(program, options, context);
+export class PathMappedReflectorHost extends ReflectorHost {
+  constructor(
+      program: ts.Program, compilerHost: ts.CompilerHost, options: AngularCompilerOptions,
+      context?: ReflectorHostContext) {
+    super(program, compilerHost, options, context);
   }
 
   getCanonicalFileName(fileName: string): string {
@@ -40,14 +42,7 @@ export class PathMappedCompilerHost extends CompilerHost {
     return fileName;
   }
 
-  moduleNameToFileName(m: string, containingFile: string) {
-    if (!containingFile || !containingFile.length) {
-      if (m.indexOf('.') === 0) {
-        throw new Error('Resolution of relative paths requires a containing file.');
-      }
-      // Any containing file gives the same result for absolute imports
-      containingFile = this.getCanonicalFileName(path.join(this.basePath, 'index.ts'));
-    }
+  protected resolve(m: string, containingFile: string) {
     for (const root of this.options.rootDirs || ['']) {
       const rootedContainingFile = path.join(root, containingFile);
       const resolved =
@@ -56,7 +51,7 @@ export class PathMappedCompilerHost extends CompilerHost {
         if (this.options.traceResolution) {
           console.error('resolve', m, containingFile, '=>', resolved.resolvedFileName);
         }
-        return this.getCanonicalFileName(resolved.resolvedFileName);
+        return resolved.resolvedFileName;
       }
     }
   }
@@ -67,7 +62,10 @@ export class PathMappedCompilerHost extends CompilerHost {
    * Relativize the paths by checking candidate prefixes of the absolute path, to see if
    * they are resolvable by the moduleResolution strategy from the CompilerHost.
    */
-  fileNameToModuleName(importedFile: string, containingFile: string): string {
+  getImportPath(containingFile: string, importedFile: string): string {
+    importedFile = this.resolveAssetUrl(importedFile, containingFile);
+    containingFile = this.resolveAssetUrl(containingFile, '');
+
     if (this.options.traceResolution) {
       console.error(
           'getImportPath from containingFile', containingFile, 'to importedFile', importedFile);
@@ -84,7 +82,7 @@ export class PathMappedCompilerHost extends CompilerHost {
     }
 
     const resolvable = (candidate: string) => {
-      const resolved = this.moduleNameToFileName(candidate, importedFile);
+      const resolved = this.getCanonicalFileName(this.resolve(candidate, importedFile));
       return resolved && resolved.replace(EXT, '') === importedFile.replace(EXT, '');
     };
 
@@ -114,10 +112,10 @@ export class PathMappedCompilerHost extends CompilerHost {
         `Unable to find any resolvable import for ${importedFile} relative to ${containingFile}`);
   }
 
-  getMetadataFor(filePath: string): ModuleMetadata[] {
+  getMetadataFor(filePath: string): ModuleMetadata {
     for (const root of this.options.rootDirs || []) {
       const rootedPath = path.join(root, filePath);
-      if (!this.context.fileExists(rootedPath)) {
+      if (!this.compilerHost.fileExists(rootedPath)) {
         // If the file doesn't exists then we cannot return metadata for the file.
         // This will occur if the user refernced a declared module for which no file
         // exists for the module (i.e. jQuery or angularjs).
@@ -126,13 +124,16 @@ export class PathMappedCompilerHost extends CompilerHost {
       if (DTS.test(rootedPath)) {
         const metadataPath = rootedPath.replace(DTS, '.metadata.json');
         if (this.context.fileExists(metadataPath)) {
-          return this.readMetadata(metadataPath, rootedPath);
+          const metadata = this.readMetadata(metadataPath);
+          return (Array.isArray(metadata) && metadata.length == 0) ? undefined : metadata;
         }
       } else {
-        const sf = this.getSourceFile(rootedPath);
-        sf.fileName = sf.fileName;
-        const metadata = this.metadataCollector.getMetadata(sf);
-        return metadata ? [metadata] : [];
+        const sf = this.program.getSourceFile(rootedPath);
+        if (!sf) {
+          throw new Error(`Source file ${rootedPath} not present in program.`);
+        }
+        sf.fileName = this.getCanonicalFileName(sf.fileName);
+        return this.metadataCollector.getMetadata(sf);
       }
     }
   }

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

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

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

@@ -0,0 +1,354 @@
+/**
+ * @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 {AssetUrl, ImportGenerator} from '@angular/compiler';
+import {AngularCompilerOptions, MetadataCollector, ModuleMetadata} from '@angular/tsc-wrapped';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import {StaticReflectorHost, StaticSymbol} from './static_reflector';
+
+const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
+const DTS = /\.d\.ts$/;
+const NODE_MODULES = '/node_modules/';
+const IS_GENERATED = /\.(ngfactory|css(\.shim)?)$/;
+
+export interface ReflectorHostContext {
+  fileExists(fileName: string): boolean;
+  directoryExists(directoryName: string): boolean;
+  readFile(fileName: string): string;
+  assumeFileExists(fileName: string): void;
+}
+
+export class ReflectorHost implements StaticReflectorHost, ImportGenerator {
+  protected metadataCollector = new MetadataCollector();
+  protected context: ReflectorHostContext;
+  private isGenDirChildOfRootDir: boolean;
+  protected basePath: string;
+  private genDir: string;
+  constructor(
+      protected program: ts.Program, protected compilerHost: ts.CompilerHost,
+      protected options: AngularCompilerOptions, context?: ReflectorHostContext) {
+    // 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 NodeReflectorHostContext(compilerHost);
+    const genPath: string = path.relative(this.basePath, this.genDir);
+    this.isGenDirChildOfRootDir = genPath === '' || !genPath.startsWith('..');
+  }
+
+  angularImportLocations() {
+    return {
+      coreDecorators: '@angular/core/src/metadata',
+      diDecorators: '@angular/core/src/di/metadata',
+      diMetadata: '@angular/core/src/di/metadata',
+      diOpaqueToken: '@angular/core/src/di/opaque_token',
+      animationMetadata: '@angular/core/src/animation/metadata',
+      provider: '@angular/core/src/di/provider'
+    };
+  }
+
+  // We use absolute paths on disk as canonical.
+  getCanonicalFileName(fileName: string): string { return fileName; }
+
+  protected resolve(m: string, containingFile: string) {
+    m = m.replace(EXT, '');
+    const resolved =
+        ts.resolveModuleName(m, containingFile.replace(/\\/g, '/'), this.options, this.context)
+            .resolvedModule;
+    return resolved ? resolved.resolvedFileName : null;
+  };
+
+  protected normalizeAssetUrl(url: string): string {
+    const assetUrl = AssetUrl.parse(url);
+    const path = assetUrl ? `${assetUrl.packageName}/${assetUrl.modulePath}` : null;
+    return this.getCanonicalFileName(path);
+  }
+
+  protected resolveAssetUrl(url: string, containingFile: string): string {
+    const assetUrl = this.normalizeAssetUrl(url);
+    if (assetUrl) {
+      return this.getCanonicalFileName(this.resolve(assetUrl, containingFile));
+    }
+    return url;
+  }
+
+  /**
+   * We want a moduleId that will appear in import statements in the generated code.
+   * These need to be in a form that system.js can load, so absolute file paths don't work.
+   *
+   * The `containingFile` is always in the `genDir`, where as the `importedFile` can be in
+   * `genDir`, `node_module` or `basePath`.  The `importedFile` is either a generated file or
+   * existing file.
+   *
+   *               | genDir   | node_module |  rootDir
+   * --------------+----------+-------------+----------
+   * generated     | relative |   relative  |   n/a
+   * existing file |   n/a    |   absolute  |  relative(*)
+   *
+   * NOTE: (*) the relative path is computed depending on `isGenDirChildOfRootDir`.
+   */
+  getImportPath(containingFile: string, importedFile: string): string {
+    importedFile = this.resolveAssetUrl(importedFile, containingFile);
+    containingFile = this.resolveAssetUrl(containingFile, '');
+
+    // 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)) {
+      this.context.assumeFileExists(importedFile);
+    }
+
+    containingFile = this.rewriteGenDirPath(containingFile);
+    const containingDir = path.dirname(containingFile);
+    // drop extension
+    importedFile = importedFile.replace(EXT, '');
+
+    const nodeModulesIndex = importedFile.indexOf(NODE_MODULES);
+    const importModule = nodeModulesIndex === -1 ?
+        null :
+        importedFile.substring(nodeModulesIndex + NODE_MODULES.length);
+    const isGeneratedFile = IS_GENERATED.test(importedFile);
+
+    if (isGeneratedFile) {
+      // rewrite to genDir path
+      if (importModule) {
+        // it is generated, therefore we do a relative path to the factory
+        return this.dotRelative(containingDir, this.genDir + NODE_MODULES + importModule);
+      } else {
+        // assume that import is also in `genDir`
+        importedFile = this.rewriteGenDirPath(importedFile);
+        return this.dotRelative(containingDir, importedFile);
+      }
+    } else {
+      // user code import
+      if (importModule) {
+        return importModule;
+      } else {
+        if (!this.isGenDirChildOfRootDir) {
+          // assume that they are on top of each other.
+          importedFile = importedFile.replace(this.basePath, this.genDir);
+        }
+        return this.dotRelative(containingDir, importedFile);
+      }
+    }
+  }
+
+  private dotRelative(from: string, to: string): string {
+    const rPath: string = path.relative(from, to).replace(/\\/g, '/');
+    return rPath.startsWith('.') ? rPath : './' + rPath;
+  }
+
+  /**
+   * Moves the path into `genDir` folder while preserving the `node_modules` directory.
+   */
+  private rewriteGenDirPath(filepath: string) {
+    const nodeModulesIndex = filepath.indexOf(NODE_MODULES);
+    if (nodeModulesIndex !== -1) {
+      // If we are in node_modulse, transplant them into `genDir`.
+      return path.join(this.genDir, filepath.substring(nodeModulesIndex));
+    } else {
+      // pretend that containing file is on top of the `genDir` to normalize the paths.
+      // we apply the `genDir` => `rootDir` delta through `rootDirPrefix` later.
+      return filepath.replace(this.basePath, this.genDir);
+    }
+  }
+
+  findDeclaration(
+      module: string, symbolName: string, containingFile: string,
+      containingModule?: string): StaticSymbol {
+    if (!containingFile || !containingFile.length) {
+      if (module.indexOf('.') === 0) {
+        throw new Error('Resolution of relative paths requires a containing file.');
+      }
+      // Any containing file gives the same result for absolute imports
+      containingFile = path.join(this.basePath, 'index.ts');
+    }
+
+    try {
+      const assetUrl = this.normalizeAssetUrl(module);
+      if (assetUrl) {
+        module = assetUrl;
+      }
+      const filePath = this.resolve(module, containingFile);
+
+      if (!filePath) {
+        // If the file cannot be found the module is probably referencing a declared module
+        // for which there is no disambiguating file and we also don't need to track
+        // re-exports. Just use the module name.
+        return this.getStaticSymbol(module, symbolName);
+      }
+
+      const tc = this.program.getTypeChecker();
+      const sf = this.program.getSourceFile(filePath);
+      if (!sf || !(<any>sf).symbol) {
+        // The source file was not needed in the compile but we do need the values from
+        // the corresponding .ts files stored in the .metadata.json file. Check the file
+        // for exports to see if the file is exported.
+        return this.resolveExportedSymbol(filePath, symbolName) ||
+            this.getStaticSymbol(filePath, symbolName);
+      }
+
+      let symbol = tc.getExportsOfModule((<any>sf).symbol).find(m => m.name === symbolName);
+      if (!symbol) {
+        throw new Error(`can't find symbol ${symbolName} exported from module ${filePath}`);
+      }
+      if (symbol &&
+          symbol.flags & ts.SymbolFlags.Alias) {  // This is an alias, follow what it aliases
+        symbol = tc.getAliasedSymbol(symbol);
+      }
+      const declaration = symbol.getDeclarations()[0];
+      const declarationFile = this.getCanonicalFileName(declaration.getSourceFile().fileName);
+
+      return this.getStaticSymbol(declarationFile, symbol.getName());
+    } catch (e) {
+      console.error(`can't resolve module ${module} from ${containingFile}`);
+      throw e;
+    }
+  }
+
+  private typeCache = new Map<string, StaticSymbol>();
+  private resolverCache = new Map<string, ModuleMetadata>();
+
+  /**
+   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
+   * All types passed to the StaticResolver should be pseudo-types returned by this method.
+   *
+   * @param declarationFile the absolute path of the file where the symbol is declared
+   * @param name the name of the type.
+   */
+  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    const memberSuffix = members ? `.${ members.join('.')}` : '';
+    const key = `"${declarationFile}".${name}${memberSuffix}`;
+    let result = this.typeCache.get(key);
+    if (!result) {
+      result = new StaticSymbol(declarationFile, name, members);
+      this.typeCache.set(key, result);
+    }
+    return result;
+  }
+
+  getMetadataFor(filePath: string): ModuleMetadata {
+    if (!this.context.fileExists(filePath)) {
+      // 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).
+      return;
+    }
+    if (DTS.test(filePath)) {
+      const metadataPath = filePath.replace(DTS, '.metadata.json');
+      if (this.context.fileExists(metadataPath)) {
+        const metadata = this.readMetadata(metadataPath);
+        return (Array.isArray(metadata) && metadata.length == 0) ? undefined : metadata;
+      }
+    } else {
+      const sf = this.program.getSourceFile(filePath);
+      if (!sf) {
+        if (this.context.fileExists(filePath)) {
+          const sourceText = this.context.readFile(filePath);
+          return this.metadataCollector.getMetadata(
+              ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true));
+        }
+
+        throw new Error(`Source file ${filePath} not present in program.`);
+      }
+      return this.metadataCollector.getMetadata(sf);
+    }
+  }
+
+  readMetadata(filePath: string) {
+    try {
+      return this.resolverCache.get(filePath) || JSON.parse(this.context.readFile(filePath));
+    } catch (e) {
+      console.error(`Failed to read JSON file ${filePath}`);
+      throw e;
+    }
+  }
+
+  private getResolverMetadata(filePath: string): ModuleMetadata {
+    let metadata = this.resolverCache.get(filePath);
+    if (!metadata) {
+      metadata = this.getMetadataFor(filePath);
+      this.resolverCache.set(filePath, metadata);
+    }
+    return metadata;
+  }
+
+  protected resolveExportedSymbol(filePath: string, symbolName: string): StaticSymbol {
+    const resolveModule = (moduleName: string): string => {
+      const resolvedModulePath = this.getCanonicalFileName(this.resolve(moduleName, filePath));
+      if (!resolvedModulePath) {
+        throw new Error(`Could not resolve module '${moduleName}' relative to file ${filePath}`);
+      }
+      return resolvedModulePath;
+    };
+    const metadata = this.getResolverMetadata(filePath);
+    if (metadata) {
+      // If we have metadata for the symbol, this is the original exporting location.
+      if (metadata.metadata[symbolName]) {
+        return this.getStaticSymbol(filePath, symbolName);
+      }
+
+      // If no, try to find the symbol in one of the re-export location
+      if (metadata.exports) {
+        // Try and find the symbol in the list of explicitly re-exported symbols.
+        for (const moduleExport of metadata.exports) {
+          if (moduleExport.export) {
+            const exportSymbol = moduleExport.export.find(symbol => {
+              if (typeof symbol === 'string') {
+                return symbol == symbolName;
+              } else {
+                return symbol.as == symbolName;
+              }
+            });
+            if (exportSymbol) {
+              let symName = symbolName;
+              if (typeof exportSymbol !== 'string') {
+                symName = exportSymbol.name;
+              }
+              return this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+            }
+          }
+        }
+
+        // Try to find the symbol via export * directives.
+        for (const moduleExport of metadata.exports) {
+          if (!moduleExport.export) {
+            const resolvedModule = resolveModule(moduleExport.from);
+            const candidateSymbol = this.resolveExportedSymbol(resolvedModule, symbolName);
+            if (candidateSymbol) return candidateSymbol;
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
+
+export class NodeReflectorHostContext implements ReflectorHostContext {
+  constructor(private host: ts.CompilerHost) {}
+
+  private assumedExists: {[fileName: string]: boolean} = {};
+
+  fileExists(fileName: string): boolean {
+    return this.assumedExists[fileName] || this.host.fileExists(fileName);
+  }
+
+  directoryExists(directoryName: string): boolean {
+    try {
+      return fs.statSync(directoryName).isDirectory();
+    } catch (e) {
+      return false;
+    }
+  }
+
+  readFile(fileName: string): string { return fs.readFileSync(fileName, 'utf8'); }
+
+  assumeFileExists(fileName: string): void { this.assumedExists[fileName] = true; }
+}

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

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

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

@@ -0,0 +1,674 @@
+/**
+ * @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 {Attribute, Component, ContentChild, ContentChildren, Directive, Host, HostBinding, HostListener, Inject, Injectable, Input, NgModule, Optional, Output, Pipe, Self, SkipSelf, ViewChild, ViewChildren, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
+
+import {ReflectorReader} from './private_import_core';
+
+const SUPPORTED_SCHEMA_VERSION = 1;
+
+/**
+ * The host of the static resolver is expected to be able to provide module metadata in the form of
+ * ModuleMetadata. Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
+ * produced and the module has exported variables or classes with decorators. Module metadata can
+ * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
+ */
+export interface StaticReflectorHost {
+  /**
+   * Return a ModuleMetadata for the given module.
+   *
+   * @param modulePath is a string identifier for a module as an absolute path.
+   * @returns the metadata for the given module.
+   */
+  getMetadataFor(modulePath: string): {[key: string]: any}|{[key: string]: any}[];
+
+  /**
+   * Resolve a symbol from an import statement form, to the file where it is declared.
+   * @param module the location imported from
+   * @param containingFile for relative imports, the path of the file containing the import
+   */
+  findDeclaration(modulePath: string, symbolName: string, containingFile?: string): StaticSymbol;
+
+  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol;
+
+  angularImportLocations(): {
+    coreDecorators: string,
+    diDecorators: string,
+    diMetadata: string,
+    diOpaqueToken: string,
+    animationMetadata: string,
+    provider: string
+  };
+
+  getCanonicalFileName(fileName: string): string;
+}
+
+/**
+ * A token representing the a reference to a static type.
+ *
+ * This token is unique for a filePath and name and can be used as a hash table key.
+ */
+export class StaticSymbol {
+  constructor(public filePath: string, public name: string, public members?: string[]) {}
+}
+
+/**
+ * A static reflector implements enough of the Reflector API that is necessary to compile
+ * templates statically.
+ */
+export class StaticReflector implements ReflectorReader {
+  private annotationCache = new Map<StaticSymbol, any[]>();
+  private propertyCache = new Map<StaticSymbol, {[key: string]: any}>();
+  private parameterCache = new Map<StaticSymbol, any[]>();
+  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) { this.initializeConversionMap(); }
+
+  importUri(typeOrFunc: StaticSymbol): string {
+    const staticSymbol = this.host.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
+    return staticSymbol ? staticSymbol.filePath : null;
+  }
+
+  resolveIdentifier(name: string, moduleUrl: string, runtime: any): any {
+    return this.host.findDeclaration(moduleUrl, name, '');
+  }
+
+  resolveEnum(enumIdentifier: any, name: string): any {
+    const staticSymbol: StaticSymbol = enumIdentifier;
+    return this.host.getStaticSymbol(staticSymbol.filePath, staticSymbol.name, [name]);
+  }
+
+  public annotations(type: StaticSymbol): any[] {
+    let annotations = this.annotationCache.get(type);
+    if (!annotations) {
+      const classMetadata = this.getTypeMetadata(type);
+      if (classMetadata['decorators']) {
+        annotations = this.simplify(type, classMetadata['decorators']);
+      } else {
+        annotations = [];
+      }
+      this.annotationCache.set(type, annotations.filter(ann => !!ann));
+    }
+    return annotations;
+  }
+
+  public propMetadata(type: StaticSymbol): {[key: string]: any} {
+    let propMetadata = this.propertyCache.get(type);
+    if (!propMetadata) {
+      const classMetadata = this.getTypeMetadata(type);
+      const members = classMetadata ? classMetadata['members'] : {};
+      propMetadata = mapStringMap(members, (propData, propName) => {
+        const prop = (<any[]>propData)
+                         .find(a => a['__symbolic'] == 'property' || a['__symbolic'] == 'method');
+        if (prop && prop['decorators']) {
+          return this.simplify(type, prop['decorators']);
+        } else {
+          return [];
+        }
+      });
+      this.propertyCache.set(type, propMetadata);
+    }
+    return propMetadata;
+  }
+
+  public parameters(type: StaticSymbol): any[] {
+    if (!(type instanceof StaticSymbol)) {
+      throw new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`);
+    }
+    try {
+      let parameters = this.parameterCache.get(type);
+      if (!parameters) {
+        const classMetadata = this.getTypeMetadata(type);
+        const members = classMetadata ? classMetadata['members'] : null;
+        const ctorData = members ? members['__ctor__'] : null;
+        if (ctorData) {
+          const ctor = (<any[]>ctorData).find(a => a['__symbolic'] == 'constructor');
+          const parameterTypes = <any[]>this.simplify(type, ctor['parameters'] || []);
+          const parameterDecorators = <any[]>this.simplify(type, ctor['parameterDecorators'] || []);
+          parameters = [];
+          parameterTypes.forEach((paramType, index) => {
+            const nestedResult: any[] = [];
+            if (paramType) {
+              nestedResult.push(paramType);
+            }
+            const decorators = parameterDecorators ? parameterDecorators[index] : null;
+            if (decorators) {
+              nestedResult.push(...decorators);
+            }
+            parameters.push(nestedResult);
+          });
+        }
+        if (!parameters) {
+          parameters = [];
+        }
+        this.parameterCache.set(type, parameters);
+      }
+      return parameters;
+    } catch (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`);
+    }
+    const classMetadata = this.getTypeMetadata(type);
+    const members = classMetadata ? classMetadata['members'] : null;
+    const member: any[] =
+        members && members.hasOwnProperty(lcProperty) ? members[lcProperty] : null;
+    return member ? member.some(a => a['__symbolic'] == 'method') : false;
+  }
+
+  private registerDecoratorOrConstructor(type: StaticSymbol, ctor: any): void {
+    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => new ctor(...args));
+  }
+
+  private registerFunction(type: StaticSymbol, fn: any): void {
+    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => fn.apply(undefined, args));
+  }
+
+  private initializeConversionMap(): void {
+    const {coreDecorators, diDecorators, diMetadata, diOpaqueToken, animationMetadata, provider} =
+        this.host.angularImportLocations();
+    this.opaqueToken = this.host.findDeclaration(diOpaqueToken, 'OpaqueToken');
+
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(diDecorators, 'Host'), Host);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(diDecorators, 'Injectable'), Injectable);
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(diDecorators, 'Self'), Self);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(diDecorators, 'SkipSelf'), SkipSelf);
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(diDecorators, 'Inject'), Inject);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(diDecorators, 'Optional'), Optional);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'Attribute'), Attribute);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'ContentChild'), ContentChild);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'ContentChildren'), ContentChildren);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'ViewChild'), ViewChild);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'ViewChildren'), ViewChildren);
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(coreDecorators, 'Input'), Input);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'Output'), Output);
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(coreDecorators, 'Pipe'), Pipe);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'HostBinding'), HostBinding);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'HostListener'), HostListener);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'Directive'), Directive);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'Component'), Component);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(coreDecorators, 'NgModule'), NgModule);
+
+    // Note: Some metadata classes can be used directly with Provider.deps.
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(diMetadata, 'Host'), Host);
+    this.registerDecoratorOrConstructor(this.host.findDeclaration(diMetadata, 'Self'), Self);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(diMetadata, 'SkipSelf'), SkipSelf);
+    this.registerDecoratorOrConstructor(
+        this.host.findDeclaration(diMetadata, 'Optional'), Optional);
+
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'trigger'), trigger);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'state'), state);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'transition'), transition);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'style'), style);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'animate'), animate);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'keyframes'), keyframes);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'sequence'), sequence);
+    this.registerFunction(this.host.findDeclaration(animationMetadata, 'group'), group);
+  }
+
+  /** @internal */
+  public simplify(context: StaticSymbol, value: any): any {
+    const _this = this;
+    let scope = BindingScope.empty;
+    const calling = new Map<StaticSymbol, boolean>();
+
+    function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
+      function resolveReference(context: StaticSymbol, expression: any): StaticSymbol {
+        let staticSymbol: StaticSymbol;
+        if (expression['module']) {
+          staticSymbol = _this.host.findDeclaration(
+              expression['module'], expression['name'], context.filePath);
+        } else {
+          staticSymbol = _this.host.getStaticSymbol(context.filePath, expression['name']);
+        }
+        return staticSymbol;
+      }
+
+      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
+        const moduleMetadata = _this.getModuleMetadata(staticSymbol.filePath);
+        const declarationValue =
+            moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
+        return declarationValue;
+      }
+
+      function isOpaqueToken(context: StaticSymbol, value: any): boolean {
+        if (value && value.__symbolic === 'new' && value.expression) {
+          const target = value.expression;
+          if (target.__symbolic == 'reference') {
+            return sameSymbol(resolveReference(context, target), _this.opaqueToken);
+          }
+        }
+        return false;
+      }
+
+      function simplifyCall(expression: any) {
+        let callContext: {[name: string]: string}|undefined = undefined;
+        if (expression['__symbolic'] == 'call') {
+          const target = expression['expression'];
+          let functionSymbol: StaticSymbol;
+          let targetFunction: any;
+          if (target) {
+            switch (target.__symbolic) {
+              case 'reference':
+                // Find the function to call.
+                callContext = {name: target.name};
+                functionSymbol = resolveReference(context, target);
+                targetFunction = resolveReferenceValue(functionSymbol);
+                break;
+              case 'select':
+                // Find the static method to call
+                if (target.expression.__symbolic == 'reference') {
+                  functionSymbol = resolveReference(context, target.expression);
+                  const classData = resolveReferenceValue(functionSymbol);
+                  if (classData && classData.statics) {
+                    targetFunction = classData.statics[target.member];
+                  }
+                }
+                break;
+            }
+          }
+          if (targetFunction && targetFunction['__symbolic'] == 'function') {
+            if (calling.get(functionSymbol)) {
+              throw new Error('Recursion not supported');
+            }
+            calling.set(functionSymbol, true);
+            try {
+              const value = targetFunction['value'];
+              if (value && (depth != 0 || value.__symbolic != 'error')) {
+                // Determine the arguments
+                const args: any[] =
+                    (expression['arguments'] || []).map((arg: any) => simplify(arg));
+                const parameters: string[] = targetFunction['parameters'];
+                const defaults: any[] = targetFunction.defaults;
+                if (defaults && defaults.length > args.length) {
+                  args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
+                }
+                const functionScope = BindingScope.build();
+                for (let i = 0; i < parameters.length; i++) {
+                  functionScope.define(parameters[i], args[i]);
+                }
+                const oldScope = scope;
+                let result: any;
+                try {
+                  scope = functionScope.done();
+                  result = simplifyInContext(functionSymbol, value, depth + 1);
+                } finally {
+                  scope = oldScope;
+                }
+                return result;
+              }
+            } finally {
+              calling.delete(functionSymbol);
+            }
+          }
+        }
+
+        if (depth === 0) {
+          // If depth is 0 we are evaluating the top level expression that is describing element
+          // decorator. In this case, it is a decorator we don't understand, such as a custom
+          // non-angular decorator, and we should just ignore it.
+          return {__symbolic: 'ignore'};
+        }
+        return simplify(
+            {__symbolic: 'error', message: 'Function call not supported', context: callContext});
+      }
+
+      function simplify(expression: any): any {
+        if (isPrimitive(expression)) {
+          return expression;
+        }
+        if (expression instanceof Array) {
+          const result: any[] = [];
+          for (const item of (<any>expression)) {
+            // Check for a spread expression
+            if (item && item.__symbolic === 'spread') {
+              const spreadArray = simplify(item.expression);
+              if (Array.isArray(spreadArray)) {
+                for (const spreadItem of spreadArray) {
+                  result.push(spreadItem);
+                }
+                continue;
+              }
+            }
+            const value = simplify(item);
+            if (shouldIgnore(value)) {
+              continue;
+            }
+            result.push(value);
+          }
+          return result;
+        }
+        if (expression instanceof StaticSymbol) {
+          return expression;
+        }
+        if (expression) {
+          if (expression['__symbolic']) {
+            let staticSymbol: StaticSymbol;
+            switch (expression['__symbolic']) {
+              case 'binop':
+                let left = simplify(expression['left']);
+                if (shouldIgnore(left)) return left;
+                let right = simplify(expression['right']);
+                if (shouldIgnore(right)) return right;
+                switch (expression['operator']) {
+                  case '&&':
+                    return left && right;
+                  case '||':
+                    return left || right;
+                  case '|':
+                    return left | right;
+                  case '^':
+                    return left ^ right;
+                  case '&':
+                    return left & right;
+                  case '==':
+                    return left == right;
+                  case '!=':
+                    return left != right;
+                  case '===':
+                    return left === right;
+                  case '!==':
+                    return left !== right;
+                  case '<':
+                    return left < right;
+                  case '>':
+                    return left > right;
+                  case '<=':
+                    return left <= right;
+                  case '>=':
+                    return left >= right;
+                  case '<<':
+                    return left << right;
+                  case '>>':
+                    return left >> right;
+                  case '+':
+                    return left + right;
+                  case '-':
+                    return left - right;
+                  case '*':
+                    return left * right;
+                  case '/':
+                    return left / right;
+                  case '%':
+                    return left % right;
+                }
+                return null;
+              case 'if':
+                let condition = simplify(expression['condition']);
+                return condition ? simplify(expression['thenExpression']) :
+                                   simplify(expression['elseExpression']);
+              case 'pre':
+                let operand = simplify(expression['operand']);
+                if (shouldIgnore(operand)) return operand;
+                switch (expression['operator']) {
+                  case '+':
+                    return operand;
+                  case '-':
+                    return -operand;
+                  case '!':
+                    return !operand;
+                  case '~':
+                    return ~operand;
+                }
+                return null;
+              case 'index':
+                let indexTarget = simplify(expression['expression']);
+                let index = simplify(expression['index']);
+                if (indexTarget && isPrimitive(index)) return indexTarget[index];
+                return null;
+              case 'select':
+                let selectTarget = simplify(expression['expression']);
+                if (selectTarget instanceof StaticSymbol) {
+                  // Access to a static instance variable
+                  const declarationValue = resolveReferenceValue(selectTarget);
+                  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.host.getStaticSymbol(
+                        selectTarget.filePath, selectTarget.name, members);
+                  }
+                }
+                const member = simplify(expression['member']);
+                if (selectTarget && isPrimitive(member)) return simplify(selectTarget[member]);
+                return null;
+              case 'reference':
+                if (!expression.module) {
+                  const name: string = expression['name'];
+                  const localValue = scope.resolve(name);
+                  if (localValue != BindingScope.missing) {
+                    return localValue;
+                  }
+                }
+                staticSymbol = resolveReference(context, expression);
+                let result: any = staticSymbol;
+                let declarationValue = resolveReferenceValue(result);
+                if (declarationValue) {
+                  if (isOpaqueToken(staticSymbol, declarationValue)) {
+                    // If the referenced symbol is initalized by a new OpaqueToken we can keep the
+                    // reference to the symbol.
+                    return staticSymbol;
+                  }
+                  result = simplifyInContext(staticSymbol, declarationValue, depth + 1);
+                }
+                return result;
+              case 'class':
+                return context;
+              case 'function':
+                return context;
+              case 'new':
+              case 'call':
+                // Determine if the function is a built-in conversion
+                let target = expression['expression'];
+                if (target['module']) {
+                  staticSymbol = _this.host.findDeclaration(
+                      target['module'], target['name'], context.filePath);
+                } else {
+                  staticSymbol = _this.host.getStaticSymbol(context.filePath, target['name']);
+                }
+                let converter = _this.conversionMap.get(staticSymbol);
+                if (converter) {
+                  let args: any[] = expression['arguments'];
+                  if (!args) {
+                    args = [];
+                  }
+                  return converter(
+                      context, args.map(arg => simplifyInContext(context, arg, depth + 1)));
+                }
+
+                // Determine if the function is one we can simplify.
+                return simplifyCall(expression);
+
+              case 'error':
+                let message = produceErrorMessage(expression);
+                if (expression['line']) {
+                  message =
+                      `${message} (position ${expression['line']+1}:${expression['character']+1} in the original .ts file)`;
+                  throw positionalError(
+                      message, context.filePath, expression['line'], expression['character']);
+                }
+                throw new Error(message);
+            }
+            return null;
+          }
+          return mapStringMap(expression, (value, name) => simplify(value));
+        }
+        return null;
+      }
+
+      try {
+        return simplify(value);
+      } catch (e) {
+        const message = `${e.message}, resolving symbol ${context.name} in ${context.filePath}`;
+        if (e.fileName) {
+          throw positionalError(message, e.fileName, e.line, e.column);
+        }
+        throw new Error(message);
+      }
+    }
+
+    const result = simplifyInContext(context, value, 0);
+    if (shouldIgnore(result)) {
+      return undefined;
+    }
+    return result;
+  }
+
+  /**
+   * @param module an absolute path to a module file.
+   */
+  public getModuleMetadata(module: string): {[key: string]: any} {
+    let moduleMetadata = this.metadataCache.get(module);
+    if (!moduleMetadata) {
+      moduleMetadata = this.host.getMetadataFor(module);
+      if (Array.isArray(moduleMetadata)) {
+        moduleMetadata = moduleMetadata.find(md => md['version'] === SUPPORTED_SCHEMA_VERSION) ||
+            moduleMetadata[0];
+      }
+      if (!moduleMetadata) {
+        moduleMetadata =
+            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
+      }
+      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
+        throw new Error(
+            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`);
+      }
+      this.metadataCache.set(module, moduleMetadata);
+    }
+    return moduleMetadata;
+  }
+
+  private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
+    const moduleMetadata = this.getModuleMetadata(type.filePath);
+    return moduleMetadata['metadata'][type.name] || {__symbolic: 'class'};
+  }
+}
+
+function expandedMessage(error: any): string {
+  switch (error.message) {
+    case 'Reference to non-exported class':
+      if (error.context && error.context.className) {
+        return `Reference to a non-exported class ${error.context.className}. Consider exporting the class`;
+      }
+      break;
+    case 'Variable not initialized':
+      return 'Only initialized variables and constants can be referenced because the value of this variable is needed by the template compiler';
+    case 'Destructuring not supported':
+      return 'Referencing an exported destructured variable or constant is not supported by the template compiler. Consider simplifying this to avoid destructuring';
+    case 'Could not resolve type':
+      if (error.context && error.context.typeName) {
+        return `Could not resolve type ${error.context.typeName}`;
+      }
+      break;
+    case 'Function call not supported':
+      let prefix =
+          error.context && error.context.name ? `Calling function '${error.context.name}', f` : 'F';
+      return prefix +
+          'unction calls are not supported. Consider replacing the function or lambda with a reference to an exported function';
+    case 'Reference to a local symbol':
+      if (error.context && error.context.name) {
+        return `Reference to a local (non-exported) symbol '${error.context.name}'. Consider exporting the symbol`;
+      }
+  }
+  return error.message;
+}
+
+function produceErrorMessage(error: any): string {
+  return `Error encountered resolving symbol values statically. ${expandedMessage(error)}`;
+}
+
+function mapStringMap(input: {[key: string]: any}, transform: (value: any, key: string) => any):
+    {[key: string]: any} {
+  if (!input) return {};
+  const result: {[key: string]: any} = {};
+  Object.keys(input).forEach((key) => {
+    const value = transform(input[key], key);
+    if (!shouldIgnore(value)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+
+function isPrimitive(o: any): boolean {
+  return o === null || (typeof o !== 'function' && typeof o !== 'object');
+}
+
+interface BindingScopeBuilder {
+  define(name: string, value: any): BindingScopeBuilder;
+  done(): BindingScope;
+}
+
+abstract class BindingScope {
+  abstract resolve(name: string): any;
+  public static missing = {};
+  public static empty: BindingScope = {resolve: name => BindingScope.missing};
+
+  public static build(): BindingScopeBuilder {
+    const current = new Map<string, any>();
+    return {
+      define: function(name, value) {
+        current.set(name, value);
+        return this;
+      },
+      done: function() {
+        return current.size > 0 ? new PopulatedScope(current) : BindingScope.empty;
+      }
+    };
+  }
+}
+
+class PopulatedScope extends BindingScope {
+  constructor(private bindings: Map<string, any>) { super(); }
+
+  resolve(name: string): any {
+    return this.bindings.has(name) ? this.bindings.get(name) : BindingScope.missing;
+  }
+}
+
+function sameSymbol(a: StaticSymbol, b: StaticSymbol): boolean {
+  return a === b || (a.name == b.name && a.filePath == b.filePath);
+}
+
+function shouldIgnore(value: any): boolean {
+  return value && value.__symbolic == 'ignore';
+}
+
+function positionalError(message: string, fileName: string, line: number, column: number): Error {
+  const result = new Error(message);
+  (result as any).fileName = fileName;
+  (result as any).line = line;
+  (result as any).column = column;
+  return result;
+}

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

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

@@ -1,260 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {ModuleMetadata} from '@angular/tsc-wrapped';
-import * as ts from 'typescript';
-
-import {CompilerHost} from '../src/compiler_host';
-
-import {Directory, Entry, MockAotContext, MockCompilerHost} from './mocks';
-
-describe('CompilerHost', () => {
-  let context: MockAotContext;
-  let program: ts.Program;
-  let hostNestedGenDir: CompilerHost;
-  let hostSiblingGenDir: CompilerHost;
-
-  beforeEach(() => {
-    context = new MockAotContext('/tmp/src', clone(FILES));
-    const host = new MockCompilerHost(context);
-    program = ts.createProgram(
-        ['main.ts'], {
-          module: ts.ModuleKind.CommonJS,
-        },
-        host);
-    // Force a typecheck
-    const errors = program.getSemanticDiagnostics();
-    if (errors && errors.length) {
-      throw new Error('Expected no errors');
-    }
-    hostNestedGenDir = new CompilerHost(
-        program, {
-          genDir: '/tmp/project/src/gen/',
-          basePath: '/tmp/project/src',
-          skipMetadataEmit: false,
-          strictMetadataEmit: false,
-          skipTemplateCodegen: false,
-          trace: false
-        },
-        context);
-    hostSiblingGenDir = new CompilerHost(
-        program, {
-          genDir: '/tmp/project/gen',
-          basePath: '/tmp/project/src/',
-          skipMetadataEmit: false,
-          strictMetadataEmit: false,
-          skipTemplateCodegen: false,
-          trace: false
-        },
-        context);
-  });
-
-  describe('nestedGenDir', () => {
-    it('should import node_module from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/node_modules/@angular/core.d.ts',
-                 '/tmp/project/src/gen/my.ngfactory.ts', ))
-          .toEqual('@angular/core');
-    });
-
-    it('should import factory from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ngfactory.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other.ngfactory');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.css.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css.ngstyle');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.shim.ngstyle.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.shim.ngstyle');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.sass.ngstyle.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.sass.ngstyle');
-    });
-
-    it('should import application from factory', () => {
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('../my.other');
-      expect(hostNestedGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../../my.other');
-      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');
-    });
-  });
-
-  describe('siblingGenDir', () => {
-    it('should import node_module from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/node_modules/@angular/core.d.ts',
-                 '/tmp/project/src/gen/my.ngfactory.ts'))
-          .toEqual('@angular/core');
-    });
-
-    it('should import factory from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ngfactory.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other.ngfactory');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.css.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other.css');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.css.shim.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other.css.shim');
-    });
-
-    it('should import application from factory', () => {
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./my.other');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/my.other.ts', '/tmp/project/src/a/my.ngfactory.ts'))
-          .toEqual('../my.other');
-      expect(hostSiblingGenDir.fileNameToModuleName(
-                 '/tmp/project/src/a/my.other.ts', '/tmp/project/src/my.ngfactory.ts'))
-          .toEqual('./a/my.other');
-    });
-  });
-
-  it('should be able to produce an import from main @angular/core', () => {
-    expect(hostNestedGenDir.fileNameToModuleName(
-               '/tmp/project/node_modules/@angular/core.d.ts', '/tmp/project/src/main.ts'))
-        .toEqual('@angular/core');
-  });
-
-  it('should be able to produce an import from main to a sub-directory', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/utils.ts', 'main.ts')).toEqual('./lib/utils');
-  });
-
-  it('should be able to produce an import from to a peer file', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/collections.ts', 'lib/utils.ts'))
-        .toEqual('./collections');
-  });
-
-  it('should be able to produce an import from to a sibling directory', () => {
-    expect(hostNestedGenDir.fileNameToModuleName('lib/utils.ts', 'lib2/utils2.ts'))
-        .toEqual('../lib/utils');
-  });
-
-  it('should be able to read a metadata file', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {foo: {__symbolic: 'class'}}}
-    ]);
-  });
-
-  it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toEqual([
-      dummyMetadata
-    ]);
-  });
-
-  it('should be able to read empty metadata ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/empty.d.ts')).toEqual([]);
-  });
-
-  it('should return undefined for missing modules', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/missing.d.ts')).toBeUndefined();
-  });
-
-  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: 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']}],
-      }
-    ]);
-  });
-
-  it('should upgrade a missing metadata file into v3', () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1_empty.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {}, exports: [{from: './lib/utils'}]}
-    ]);
-  });
-});
-
-const dummyModule = 'export let foo: any[];';
-const dummyMetadata: ModuleMetadata = {
-  __symbolic: 'module',
-  version: 3,
-  metadata:
-      {foo: {__symbolic: 'error', message: 'Variable not initialized', line: 0, character: 11}}
-};
-const FILES: Entry = {
-  'tmp': {
-    'src': {
-      'main.ts': `
-        import * as c from '@angular/core';
-        import * as r from '@angular/router';
-        import * as u from './lib/utils';
-        import * as cs from './lib/collections';
-        import * as u2 from './lib2/utils2';
-      `,
-      'lib': {
-        'utils.ts': dummyModule,
-        'collections.ts': dummyModule,
-      },
-      'lib2': {'utils2.ts': dummyModule},
-      'node_modules': {
-        '@angular': {
-          'core.d.ts': dummyModule,
-          'core.metadata.json':
-              `{"__symbolic":"module", "version": 3, "metadata": {"foo": {"__symbolic": "class"}}}`,
-          'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
-          'unused.d.ts': dummyModule,
-          'empty.d.ts': 'export declare var a: string;',
-          'empty.metadata.json': '[]',
-        }
-      },
-      'metadata_versions': {
-        'v1.d.ts': `
-          import {ReExport} from './lib/utils2';
-          export {ReExport};
-
-          export {Export} from './lib/utils2';
-
-          export declare class Bar {
-            ngOnInit() {}
-          }
-          export declare class BarChild extends Bar {}
-        `,
-        'v1.metadata.json':
-            `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
-        'v1_empty.d.ts': `
-          export * from './lib/utils';
-        `
-      }
-    }
-  }
-};
-
-function clone(entry: Entry): Entry {
-  if (typeof entry === 'string') {
-    return entry;
-  } else {
-    const result: Directory = {};
-    for (const name in entry) {
-      result[name] = clone(entry[name]);
-    }
-    return result;
-  }
-}

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

@@ -1,181 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {makeTempDir} from '@angular/tsc-wrapped/test/test_support';
-import * as fs from 'fs';
-import * as path from 'path';
-
-import {main} from '../src/main';
-import {ReflectionCapabilities, reflector} from './private_import_core';
-
-
-describe('compiler-cli', () => {
-  let basePath: string;
-  let write: (fileName: string, content: string) => void;
-
-  beforeEach(() => {
-    basePath = makeTempDir();
-    write = (fileName: string, content: string) => {
-      fs.writeFileSync(path.join(basePath, fileName), content, {encoding: 'utf-8'});
-    };
-    write('tsconfig.json', `{
-      "compilerOptions": {
-        "experimentalDecorators": true,
-        "types": [],
-        "outDir": "built",
-        "declaration": true,
-        "module": "es2015",
-        "moduleResolution": "node"
-      },
-      "angularCompilerOptions": {
-        "annotateForClosureCompiler": true
-      },
-      "files": ["test.ts"]
-    }`);
-    const nodeModulesPath = path.resolve(basePath, 'node_modules');
-    fs.mkdirSync(nodeModulesPath);
-    fs.symlinkSync(path.resolve(__dirname, '..', '..'), path.resolve(nodeModulesPath, '@angular'));
-  });
-
-  // Restore reflector since AoT compiler will update it with a new static reflector
-  afterEach(() => { reflector.updateCapabilities(new ReflectionCapabilities()); });
-
-  it('should compile without errors', (done) => {
-    write('test.ts', 'export const A = 1;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error).not.toHaveBeenCalled();
-          expect(exitCode).toEqual(0);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if user input file does not exist', (done) => {
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  `Error File '` + path.join(basePath, 'test.ts') + `' not found.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if user input file is malformed', (done) => {
-    write('test.ts', 'foo;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') + `:1:1: Cannot find name 'foo'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if cannot find the imported module', (done) => {
-    write('test.ts', `import {MyClass} from './not-exist-deps';`);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') +
-                  `:1:23: Cannot find module './not-exist-deps'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if cannot import', (done) => {
-    write('empty-deps.ts', 'export const A = 1;');
-    write('test.ts', `import {MyClass} from './empty-deps';`);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') + `:1:9: Module '"` +
-                  path.join(basePath, 'empty-deps') + `"' has no exported member 'MyClass'.`);
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should not print the stack trace if type mismatches', (done) => {
-    write('empty-deps.ts', 'export const A = "abc";');
-    write('test.ts', `
-      import {A} from './empty-deps';
-      A();
-    `);
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: basePath}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error)
-              .toHaveBeenCalledWith(
-                  'Error at ' + path.join(basePath, 'test.ts') +
-                  ':3:7: Cannot invoke an expression whose type lacks a call signature.');
-          expect(mockConsole.error).not.toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-
-  it('should print the stack trace on compiler internal errors', (done) => {
-    write('test.ts', 'export const A = 1;');
-
-    const mockConsole = {error: (s: string) => {}};
-
-    spyOn(mockConsole, 'error');
-
-    main({p: 'not-exist'}, mockConsole.error)
-        .then((exitCode) => {
-          expect(mockConsole.error).toHaveBeenCalled();
-          expect(mockConsole.error).toHaveBeenCalledWith('Compilation failed');
-          expect(exitCode).toEqual(1);
-          done();
-        })
-        .catch(e => done.fail(e));
-  });
-});

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

@@ -6,14 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompilerHostContext} from '@angular/compiler-cli/src/compiler_host';
+import {ReflectorHostContext} from '@angular/compiler-cli/src/reflector_host';
 import * as ts from 'typescript';
 
 export type Entry = string | Directory;
 
 export interface Directory { [name: string]: Entry; }
 
-export class MockAotContext implements CompilerHostContext {
+export class MockContext implements ReflectorHostContext {
   constructor(public currentDirectory: string, private files: Entry) {}
 
   fileExists(fileName: string): boolean { return typeof this.getEntry(fileName) === 'string'; }
@@ -28,14 +28,6 @@ export class MockAotContext implements CompilerHostContext {
     return undefined;
   }
 
-  readResource(fileName: string): Promise<string> {
-    const result = this.readFile(fileName);
-    if (result == null) {
-      return Promise.reject(new Error(`Resource not found: ${fileName}`));
-    }
-    return Promise.resolve(result);
-  }
-
   writeFile(fileName: string, data: string): void {
     const parts = fileName.split('/');
     const name = parts.pop();
@@ -97,7 +89,7 @@ function normalize(parts: string[]): string[] {
 }
 
 export class MockCompilerHost implements ts.CompilerHost {
-  constructor(private context: MockAotContext) {}
+  constructor(private context: MockContext) {}
 
   fileExists(fileName: string): boolean { return this.context.fileExists(fileName); }
 
@@ -122,9 +114,11 @@ export class MockCompilerHost implements ts.CompilerHost {
     return ts.getDefaultLibFileName(options);
   }
 
-  writeFile: ts.WriteFileCallback = (fileName, text) => { this.context.writeFile(fileName, text); };
+  writeFile: ts.WriteFileCallback = (fileName, text) => { this.context.writeFile(fileName, text); }
 
-  getCurrentDirectory(): string { return this.context.currentDirectory; }
+  getCurrentDirectory(): string {
+    return this.context.currentDirectory;
+  }
 
   getCanonicalFileName(fileName: string): string { return fileName; }
 

modules/@angular/compiler-cli/test/private_import_core.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
- */
-
-import {__core_private__ as r} from '@angular/core';
-
-export type ReflectionCapabilities = typeof r._ReflectionCapabilities;
-export const ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
-export const reflector: typeof r.reflector = r.reflector;

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

@@ -0,0 +1,329 @@
+/**
+ * @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 {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
+import * as ts from 'typescript';
+
+import {ReflectorHost} from '../src/reflector_host';
+
+import {Directory, Entry, MockCompilerHost, MockContext} from './mocks';
+
+describe('reflector_host', () => {
+  let context: MockContext;
+  let host: ts.CompilerHost;
+  let program: ts.Program;
+  let reflectorNestedGenDir: ReflectorHost;
+  let reflectorSiblingGenDir: ReflectorHost;
+
+  beforeEach(() => {
+    context = new MockContext('/tmp/src', clone(FILES));
+    host = new MockCompilerHost(context);
+    program = ts.createProgram(
+        ['main.ts'], {
+          module: ts.ModuleKind.CommonJS,
+        },
+        host);
+    // Force a typecheck
+    const errors = program.getSemanticDiagnostics();
+    if (errors && errors.length) {
+      throw new Error('Expected no errors');
+    }
+    reflectorNestedGenDir = new ReflectorHost(
+        program, host, {
+          genDir: '/tmp/project/src/gen/',
+          basePath: '/tmp/project/src',
+          skipMetadataEmit: false,
+          strictMetadataEmit: false,
+          skipTemplateCodegen: false,
+          trace: false
+        },
+        context);
+    reflectorSiblingGenDir = new ReflectorHost(
+        program, host, {
+          genDir: '/tmp/project/gen',
+          basePath: '/tmp/project/src/',
+          skipMetadataEmit: false,
+          strictMetadataEmit: false,
+          skipTemplateCodegen: false,
+          trace: false
+        },
+        context);
+  });
+
+  describe('nestedGenDir', () => {
+    it('should import node_module from factory', () => {
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/gen/my.ngfactory.ts',
+                 '/tmp/project/node_modules/@angular/core.d.ts'))
+          .toEqual('@angular/core');
+    });
+
+    it('should import factory from factory', () => {
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/my.other.ngfactory.ts'))
+          .toEqual('./my.other.ngfactory');
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/a/my.ngfactory.ts', '/tmp/project/src/my.other.css.ts'))
+          .toEqual('../my.other.css');
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/a/my.other.css.shim.ts'))
+          .toEqual('./a/my.other.css.shim');
+    });
+
+    it('should import application from factory', () => {
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/my.other.ts'))
+          .toEqual('../my.other');
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/a/my.ngfactory.ts', '/tmp/project/src/my.other.ts'))
+          .toEqual('../../my.other');
+      expect(reflectorNestedGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/a/my.other.ts'))
+          .toEqual('../a/my.other');
+    });
+  });
+
+  describe('nestedGenDir', () => {
+    it('should import node_module from factory', () => {
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/gen/my.ngfactory.ts',
+                 '/tmp/project/node_modules/@angular/core.d.ts'))
+          .toEqual('@angular/core');
+    });
+
+    it('should import factory from factory', () => {
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/my.other.ngfactory.ts'))
+          .toEqual('./my.other.ngfactory');
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/a/my.ngfactory.ts', '/tmp/project/src/my.other.css.ts'))
+          .toEqual('../my.other.css');
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/a/my.other.css.shim.ts'))
+          .toEqual('./a/my.other.css.shim');
+    });
+
+    it('should import application from factory', () => {
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/my.other.ts'))
+          .toEqual('./my.other');
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/a/my.ngfactory.ts', '/tmp/project/src/my.other.ts'))
+          .toEqual('../my.other');
+      expect(reflectorSiblingGenDir.getImportPath(
+                 '/tmp/project/src/my.ngfactory.ts', '/tmp/project/src/a/my.other.ts'))
+          .toEqual('./a/my.other');
+    });
+  });
+
+  it('should provide the import locations for angular', () => {
+    const {coreDecorators, diDecorators, diMetadata, animationMetadata, provider} =
+        reflectorNestedGenDir.angularImportLocations();
+    expect(coreDecorators).toEqual('@angular/core/src/metadata');
+    expect(diDecorators).toEqual('@angular/core/src/di/metadata');
+    expect(diMetadata).toEqual('@angular/core/src/di/metadata');
+    expect(animationMetadata).toEqual('@angular/core/src/animation/metadata');
+    expect(provider).toEqual('@angular/core/src/di/provider');
+  });
+
+  it('should be able to produce an import from main @angular/core', () => {
+    expect(reflectorNestedGenDir.getImportPath(
+               '/tmp/project/src/main.ts', '/tmp/project/node_modules/@angular/core.d.ts'))
+        .toEqual('@angular/core');
+  });
+
+  it('should be able to produce an import from main to a sub-directory', () => {
+    expect(reflectorNestedGenDir.getImportPath('main.ts', 'lib/utils.ts')).toEqual('./lib/utils');
+  });
+
+  it('should be able to produce an import from to a peer file', () => {
+    expect(reflectorNestedGenDir.getImportPath('lib/utils.ts', 'lib/collections.ts'))
+        .toEqual('./collections');
+  });
+
+  it('should be able to produce an import from to a sibling directory', () => {
+    expect(reflectorNestedGenDir.getImportPath('lib2/utils2.ts', 'lib/utils.ts'))
+        .toEqual('../lib/utils');
+  });
+
+  it('should be able to produce a symbol for an exported symbol', () => {
+    expect(reflectorNestedGenDir.findDeclaration('@angular/router', 'foo', 'main.ts'))
+        .toBeDefined();
+  });
+
+  it('should be able to produce a symbol for values space only reference', () => {
+    expect(reflectorNestedGenDir.findDeclaration('@angular/router/src/providers', 'foo', 'main.ts'))
+        .toBeDefined();
+  });
+
+
+  it('should be produce the same symbol if asked twice', () => {
+    const foo1 = reflectorNestedGenDir.getStaticSymbol('main.ts', 'foo');
+    const foo2 = reflectorNestedGenDir.getStaticSymbol('main.ts', 'foo');
+    expect(foo1).toBe(foo2);
+  });
+
+  it('should be able to produce a symbol for a module with no file', () => {
+    expect(reflectorNestedGenDir.getStaticSymbol('angularjs', 'SomeAngularSymbol')).toBeDefined();
+  });
+
+  it('should be able to read a metadata file', () => {
+    expect(reflectorNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts'))
+        .toEqual({__symbolic: 'module', version: 1, metadata: {foo: {__symbolic: 'class'}}});
+  });
+
+  it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
+    expect(reflectorNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts'))
+        .toBeUndefined();
+  });
+
+  it('should be able to read empty metadata ', () => {
+    expect(reflectorNestedGenDir.getMetadataFor('node_modules/@angular/empty.d.ts'))
+        .toBeUndefined();
+  });
+
+  it('should return undefined for missing modules', () => {
+    expect(reflectorNestedGenDir.getMetadataFor('node_modules/@angular/missing.d.ts'))
+        .toBeUndefined();
+  });
+
+  it('should be able to trace a named export', () => {
+    const symbol = reflectorNestedGenDir.findDeclaration(
+        './reexport/reexport.d.ts', 'One', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('One');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
+  });
+
+  it('should be able to trace a renamed export', () => {
+    const symbol = reflectorNestedGenDir.findDeclaration(
+        './reexport/reexport.d.ts', 'Four', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Three');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
+  });
+
+  it('should be able to trace an export * export', () => {
+    const symbol = reflectorNestedGenDir.findDeclaration(
+        './reexport/reexport.d.ts', 'Five', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Five');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin5.d.ts');
+  });
+
+  it('should be able to trace a multi-level re-export', () => {
+    const symbol = reflectorNestedGenDir.findDeclaration(
+        './reexport/reexport.d.ts', 'Thirty', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Thirty');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin30.d.ts');
+  });
+});
+
+const dummyModule = 'export let foo: any[];';
+
+const FILES: Entry = {
+  'tmp': {
+    'src': {
+      'main.ts': `
+        import * as c from '@angular/core';
+        import * as r from '@angular/router';
+        import * as u from './lib/utils';
+        import * as cs from './lib/collections';
+        import * as u2 from './lib2/utils2';
+      `,
+      'lib': {
+        'utils.ts': dummyModule,
+        'collections.ts': dummyModule,
+      },
+      'lib2': {'utils2.ts': dummyModule},
+      'reexport': {
+        'reexport.d.ts': `
+          import * as c from '@angular/core';
+        `,
+        'reexport.metadata.json': JSON.stringify({
+          __symbolic: 'module',
+          version: 1,
+          metadata: {},
+          exports: [
+            {from: './src/origin1', export: ['One', 'Two', {name: 'Three', as: 'Four'}]},
+            {from: './src/origin5'}, {from: './src/reexport2'}
+          ]
+        }),
+        'src': {
+          'origin1.d.ts': `
+            export class One {}
+            export class Two {}
+            export class Three {}
+          `,
+          'origin1.metadata.json': JSON.stringify({
+            __symbolic: 'module',
+            version: 1,
+            metadata: {
+              One: {__symbolic: 'class'},
+              Two: {__symbolic: 'class'},
+              Three: {__symbolic: 'class'},
+            },
+          }),
+          'origin5.d.ts': `
+            export class Five {}
+          `,
+          'origin5.metadata.json': JSON.stringify({
+            __symbolic: 'module',
+            version: 1,
+            metadata: {
+              Five: {__symbolic: 'class'},
+            },
+          }),
+          'origin30.d.ts': `
+            export class Thirty {}
+          `,
+          'origin30.metadata.json': JSON.stringify({
+            __symbolic: 'module',
+            version: 1,
+            metadata: {
+              Thirty: {__symbolic: 'class'},
+            },
+          }),
+          'originNone.d.ts': dummyModule,
+          'originNone.metadata.json': JSON.stringify({
+            __symbolic: 'module',
+            version: 1,
+            metadata: {},
+          }),
+          'reexport2.d.ts': dummyModule,
+          'reexport2.metadata.json': JSON.stringify({
+            __symbolic: 'module',
+            version: 1,
+            metadata: {},
+            exports: [{from: './originNone'}, {from: './origin30'}]
+          })
+        }
+      },
+      'node_modules': {
+        '@angular': {
+          'core.d.ts': dummyModule,
+          'core.metadata.json':
+              `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
+          'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
+          'unused.d.ts': dummyModule,
+          'empty.d.ts': 'export declare var a: string;',
+          'empty.metadata.json': '[]',
+        }
+      }
+    }
+  }
+};
+
+function clone(entry: Entry): Entry {
+  if (typeof entry === 'string') {
+    return entry;
+  } else {
+    const result: Directory = {};
+    for (const name in entry) {
+      result[name] = clone(entry[name]);
+    }
+    return result;
+  }
+}

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

@@ -6,35 +6,32 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
+import {StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler-cli/src/static_reflector';
 import {HostListener, Inject, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
+import {MetadataCollector} from '@angular/tsc-wrapped';
+import * as ts from 'typescript';
 
-import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
+
+
+// This matches .ts files but not .d.ts files.
+const TS_EXT = /(^.|(?!\.d)..)\.ts$/;
 
 describe('StaticReflector', () => {
-  let noContext: StaticSymbol;
-  let host: StaticSymbolResolverHost;
-  let symbolResolver: StaticSymbolResolver;
+  const noContext = new StaticSymbol('', '');
+  let host: StaticReflectorHost;
   let reflector: StaticReflector;
 
-  function init(
-      testData: {[key: string]: any} = DEFAULT_TEST_DATA,
-      decorators: {name: string, filePath: string, ctor: any}[] = []) {
-    const symbolCache = new StaticSymbolCache();
-    host = new MockStaticSymbolResolverHost(testData);
-    symbolResolver = new StaticSymbolResolver(host, symbolCache, new MockSummaryResolver([]));
-    reflector = new StaticReflector(symbolResolver, decorators);
-    noContext = reflector.getStaticSymbol('', '');
-  }
-
-  beforeEach(() => init());
+  beforeEach(() => {
+    host = new MockReflectorHost();
+    reflector = new StaticReflector(host);
+  });
 
   function simplify(context: StaticSymbol, value: any) {
     return reflector.simplify(context, value);
   }
 
   it('should get annotations for NgFor', () => {
-    const NgFor = reflector.findDeclaration('@angular/common/src/directives/ng_for', 'NgFor');
+    const NgFor = host.findDeclaration('angular2/src/common/directives/ng_for', 'NgFor');
     const annotations = reflector.annotations(NgFor);
     expect(annotations.length).toEqual(1);
     const annotation = annotations[0];
@@ -43,15 +40,15 @@ describe('StaticReflector', () => {
   });
 
   it('should get constructor for NgFor', () => {
-    const NgFor = reflector.findDeclaration('@angular/common/src/directives/ng_for', 'NgFor');
-    const ViewContainerRef = reflector.findDeclaration(
-        '@angular/core/src/linker/view_container_ref', 'ViewContainerRef');
+    const NgFor = host.findDeclaration('angular2/src/common/directives/ng_for', 'NgFor');
+    const ViewContainerRef =
+        host.findDeclaration('angular2/src/core/linker/view_container_ref', 'ViewContainerRef');
     const TemplateRef =
-        reflector.findDeclaration('@angular/core/src/linker/template_ref', 'TemplateRef');
-    const IterableDiffers = reflector.findDeclaration(
-        '@angular/core/src/change_detection/differs/iterable_differs', 'IterableDiffers');
-    const ChangeDetectorRef = reflector.findDeclaration(
-        '@angular/core/src/change_detection/change_detector_ref', 'ChangeDetectorRef');
+        host.findDeclaration('angular2/src/core/linker/template_ref', 'TemplateRef');
+    const IterableDiffers = host.findDeclaration(
+        'angular2/src/core/change_detection/differs/iterable_differs', 'IterableDiffers');
+    const ChangeDetectorRef = host.findDeclaration(
+        'angular2/src/core/change_detection/change_detector_ref', 'ChangeDetectorRef');
 
     const parameters = reflector.parameters(NgFor);
     expect(parameters).toEqual([
@@ -61,7 +58,7 @@ describe('StaticReflector', () => {
 
   it('should get annotations for HeroDetailComponent', () => {
     const HeroDetailComponent =
-        reflector.findDeclaration('src/app/hero-detail.component', 'HeroDetailComponent');
+        host.findDeclaration('src/app/hero-detail.component', 'HeroDetailComponent');
     const annotations = reflector.annotations(HeroDetailComponent);
     expect(annotations.length).toEqual(1);
     const annotation = annotations[0];
@@ -76,44 +73,41 @@ describe('StaticReflector', () => {
     ])]);
   });
 
-  it('should get and empty annotation list for an unknown class', () => {
-    const UnknownClass = reflector.findDeclaration('src/app/app.component', 'UnknownClass');
-    const annotations = reflector.annotations(UnknownClass);
-    expect(annotations).toEqual([]);
+  it('should throw and exception for unsupported metadata versions', () => {
+    const e = host.findDeclaration('src/version-error', 'e');
+    expect(() => reflector.annotations(e))
+        .toThrow(new Error(
+            'Metadata version mismatch for module /tmp/src/version-error.d.ts, found version 100, expected 1'));
   });
 
-  it('should get and empty annotation list for a symbol with null value', () => {
-    init({
-      '/tmp/test.ts': `
-        export var x = null;
-      `
-    });
-    const annotations = reflector.annotations(reflector.getStaticSymbol('/tmp/test.ts', 'x'));
+  it('should get and empty annotation list for an unknown class', () => {
+    const UnknownClass = host.findDeclaration('src/app/app.component', 'UnknownClass');
+    const annotations = reflector.annotations(UnknownClass);
     expect(annotations).toEqual([]);
   });
 
   it('should get propMetadata for HeroDetailComponent', () => {
     const HeroDetailComponent =
-        reflector.findDeclaration('src/app/hero-detail.component', 'HeroDetailComponent');
+        host.findDeclaration('src/app/hero-detail.component', 'HeroDetailComponent');
     const props = reflector.propMetadata(HeroDetailComponent);
     expect(props['hero']).toBeTruthy();
     expect(props['onMouseOver']).toEqual([new HostListener('mouseover', ['$event'])]);
   });
 
   it('should get an empty object from propMetadata for an unknown class', () => {
-    const UnknownClass = reflector.findDeclaration('src/app/app.component', 'UnknownClass');
+    const UnknownClass = host.findDeclaration('src/app/app.component', 'UnknownClass');
     const properties = reflector.propMetadata(UnknownClass);
     expect(properties).toEqual({});
   });
 
   it('should get empty parameters list for an unknown class ', () => {
-    const UnknownClass = reflector.findDeclaration('src/app/app.component', 'UnknownClass');
+    const UnknownClass = host.findDeclaration('src/app/app.component', 'UnknownClass');
     const parameters = reflector.parameters(UnknownClass);
     expect(parameters).toEqual([]);
   });
 
   it('should provide context for errors reported by the collector', () => {
-    const SomeClass = reflector.findDeclaration('src/error-reporting', 'SomeClass');
+    const SomeClass = host.findDeclaration('src/error-reporting', 'SomeClass');
     expect(() => reflector.annotations(SomeClass))
         .toThrow(new Error(
             'Error encountered resolving symbol values statically. A reasonable error message (position 13:34 in the original .ts file), resolving symbol ErrorSym in /tmp/src/error-references.d.ts, resolving symbol Link2 in /tmp/src/error-references.d.ts, resolving symbol Link1 in /tmp/src/error-references.d.ts, resolving symbol SomeClass in /tmp/src/error-reporting.d.ts, resolving symbol SomeClass in /tmp/src/error-reporting.d.ts'));
@@ -126,7 +120,7 @@ describe('StaticReflector', () => {
   });
 
   it('should simplify a static symbol into itself', () => {
-    const staticSymbol = reflector.getStaticSymbol('', '');
+    const staticSymbol = new StaticSymbol('', '');
     expect(simplify(noContext, staticSymbol)).toBe(staticSymbol);
   });
 
@@ -303,43 +297,43 @@ describe('StaticReflector', () => {
     expect(simplify(noContext, expr)).toBe(2);
   });
 
-  it('should simplify a file reference', () => {
+  it('should simplify a module reference', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', ''),
-               reflector.getStaticSymbol('/src/extern.d.ts', 's')))
+               new StaticSymbol('/src/cases', ''),
+               ({__symbolic: 'reference', module: './extern', name: 's'})))
         .toEqual('s');
   });
 
   it('should simplify a non existing reference as a static symbol', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', ''),
-               reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting')))
-        .toEqual(reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting'));
+               new StaticSymbol('/src/cases', ''),
+               ({__symbolic: 'reference', module: './extern', name: 'nonExisting'})))
+        .toEqual(host.getStaticSymbol('/src/extern.d.ts', 'nonExisting'));
   });
 
   it('should simplify a function reference as a static symbol', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', 'myFunction'),
+               new StaticSymbol('/src/cases', 'myFunction'),
                ({__symbolic: 'function', parameters: ['a'], value: []})))
-        .toEqual(reflector.getStaticSymbol('/src/cases', 'myFunction'));
+        .toEqual(host.getStaticSymbol('/src/cases', 'myFunction'));
   });
 
   it('should simplify values initialized with a function call', () => {
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'one')))
-        .toEqual(['some-value']);
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'three')))
-        .toEqual(3);
+    expect(simplify(new StaticSymbol('/tmp/src/function-reference.ts', ''), {
+      __symbolic: 'reference',
+      name: 'one'
+    })).toEqual(['some-value']);
+    expect(simplify(new StaticSymbol('/tmp/src/function-reference.ts', ''), {
+      __symbolic: 'reference',
+      name: 'three'
+    })).toEqual(3);
   });
 
   it('should error on direct recursive calls', () => {
     expect(
         () => simplify(
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'recursion')))
+            new StaticSymbol('/tmp/src/function-reference.ts', ''),
+            {__symbolic: 'reference', name: 'recursion'}))
         .toThrow(new Error(
             'Recursion not supported, resolving symbol recursive in /tmp/src/function-recursive.d.ts, resolving symbol recursion in /tmp/src/function-reference.ts, resolving symbol  in /tmp/src/function-reference.ts'));
   });
@@ -349,12 +343,13 @@ describe('StaticReflector', () => {
     try {
       const metadata = host.getMetadataFor('/tmp/src/invalid-metadata.ts');
       expect(metadata).toBeDefined();
-      const moduleMetadata: any = metadata[0]['metadata'];
-      expect(moduleMetadata).toBeDefined();
-      const classData: any = moduleMetadata['InvalidMetadata'];
-      expect(classData).toBeDefined();
-      simplify(
-          reflector.getStaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
+      if (!Array.isArray(metadata)) {
+        const moduleMetadata: any = metadata['metadata'];
+        expect(moduleMetadata).toBeDefined();
+        const classData: any = moduleMetadata['InvalidMetadata'];
+        expect(classData).toBeDefined();
+        simplify(new StaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
+      }
     } catch (e) {
       expect(e.fileName).toBe('/tmp/src/invalid-metadata.ts');
       threw = true;
@@ -365,50 +360,81 @@ describe('StaticReflector', () => {
   it('should error on indirect recursive calls', () => {
     expect(
         () => simplify(
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'indirectRecursion')))
+            new StaticSymbol('/tmp/src/function-reference.ts', ''),
+            {__symbolic: 'reference', name: 'indirectRecursion'}))
         .toThrow(new Error(
             'Recursion not supported, resolving symbol indirectRecursion2 in /tmp/src/function-recursive.d.ts, resolving symbol indirectRecursion1 in /tmp/src/function-recursive.d.ts, resolving symbol indirectRecursion in /tmp/src/function-reference.ts, resolving symbol  in /tmp/src/function-reference.ts'));
   });
 
   it('should simplify a spread expression', () => {
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/spread.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/spread.ts', 'spread')))
-        .toEqual([0, 1, 2, 3, 4, 5]);
+    expect(simplify(new StaticSymbol('/tmp/src/spread.ts', ''), {
+      __symbolic: 'reference',
+      name: 'spread'
+    })).toEqual([0, 1, 2, 3, 4, 5]);
+  });
+
+  it('should be able to get metadata from a ts file', () => {
+    const metadata = reflector.getModuleMetadata('/tmp/src/custom-decorator-reference.ts');
+    expect(metadata).toEqual({
+      __symbolic: 'module',
+      version: 1,
+      metadata: {
+        Foo: {
+          __symbolic: 'class',
+          decorators: [{
+            __symbolic: 'call',
+            expression:
+                {__symbolic: 'reference', module: './custom-decorator', name: 'CustomDecorator'}
+          }],
+          members: {
+            foo: [{
+              __symbolic: 'property',
+              decorators: [{
+                __symbolic: 'call',
+                expression: {
+                  __symbolic: 'reference',
+                  module: './custom-decorator',
+                  name: 'CustomDecorator'
+                }
+              }]
+            }]
+          }
+        }
+      }
+    });
   });
 
   it('should be able to get metadata for a class containing a custom decorator', () => {
     const props = reflector.propMetadata(
-        reflector.getStaticSymbol('/tmp/src/custom-decorator-reference.ts', 'Foo'));
+        host.getStaticSymbol('/tmp/src/custom-decorator-reference.ts', 'Foo'));
     expect(props).toEqual({foo: []});
   });
 
   it('should read ctor parameters with forwardRef', () => {
     const src = '/tmp/src/forward-ref.ts';
-    const dep = reflector.getStaticSymbol(src, 'Dep');
-    const props = reflector.parameters(reflector.getStaticSymbol(src, 'Forward'));
+    const dep = host.getStaticSymbol(src, 'Dep');
+    const props = reflector.parameters(host.getStaticSymbol(src, 'Forward'));
     expect(props).toEqual([[dep, new Inject(dep)]]);
   });
 
   it('should report an error for invalid function calls', () => {
     expect(
-        () => reflector.annotations(
-            reflector.getStaticSymbol('/tmp/src/invalid-calls.ts', 'MyComponent')))
+        () =>
+            reflector.annotations(host.getStaticSymbol('/tmp/src/invalid-calls.ts', 'MyComponent')))
         .toThrow(new Error(
             `Error encountered resolving symbol values statically. Calling function 'someFunction', function calls are not supported. Consider replacing the function or lambda with a reference to an exported function, resolving symbol MyComponent in /tmp/src/invalid-calls.ts, resolving symbol MyComponent in /tmp/src/invalid-calls.ts`));
   });
 
   it('should be able to get metadata for a class containing a static method call', () => {
     const annotations = reflector.annotations(
-        reflector.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyComponent'));
+        host.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyComponent'));
     expect(annotations.length).toBe(1);
     expect(annotations[0].providers).toEqual({provider: 'a', useValue: 100});
   });
 
   it('should be able to get metadata for a class containing a static field reference', () => {
-    const annotations = reflector.annotations(
-        reflector.getStaticSymbol('/tmp/src/static-field-reference.ts', 'Foo'));
+    const annotations =
+        reflector.annotations(host.getStaticSymbol('/tmp/src/static-field-reference.ts', 'Foo'));
     expect(annotations.length).toBe(1);
     expect(annotations[0].providers).toEqual([{provider: 'a', useValue: 'Some string'}]);
   });
@@ -416,252 +442,119 @@ describe('StaticReflector', () => {
   it('should be able to get the metadata for a class calling a method with a conditional expression',
      () => {
        const annotations = reflector.annotations(
-           reflector.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyCondComponent'));
+           host.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyCondComponent'));
        expect(annotations.length).toBe(1);
        expect(annotations[0].providers).toEqual([
          [{provider: 'a', useValue: '1'}], [{provider: 'a', useValue: '2'}]
        ]);
      });
 
-  it('should be able to get metadata for a class with nested method calls', () => {
-    const annotations = reflector.annotations(
-        reflector.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyFactoryComponent'));
-    expect(annotations.length).toBe(1);
-    expect(annotations[0].providers).toEqual({
-      provide: 'c',
-      useFactory:
-          reflector.getStaticSymbol('/tmp/src/static-method.ts', 'AnotherModule', ['someFactory'])
-    });
-  });
-
   it('should be able to get the metadata for a class calling a method with default parameters',
      () => {
        const annotations = reflector.annotations(
-           reflector.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyDefaultsComponent'));
+           host.getStaticSymbol('/tmp/src/static-method-call.ts', 'MyDefaultsComponent'));
        expect(annotations.length).toBe(1);
        expect(annotations[0].providers).toEqual([['a', true, false]]);
      });
 
   it('should be able to get metadata with a reference to a static method', () => {
     const annotations = reflector.annotations(
-        reflector.getStaticSymbol('/tmp/src/static-method-ref.ts', 'MethodReference'));
+        host.getStaticSymbol('/tmp/src/static-method-ref.ts', 'MethodReference'));
     expect(annotations.length).toBe(1);
     expect(annotations[0].providers[0].useValue.members[0]).toEqual('staticMethod');
   });
-
-  // #13605
-  it('should not throw on unknown decorators', () => {
-    const data = Object.create(DEFAULT_TEST_DATA);
-    const file = '/tmp/src/app.component.ts';
-    data[file] = `
-      import { Component } from '@angular/core';
-
-      export const enum TypeEnum {
-        type
-      }
-
-      export function MyValidationDecorator(p1: any, p2: any): any {
-        return null;
-      }
-
-      export function ValidationFunction(a1: any): any {
-        return null;
-      }
-
-      @Component({
-        selector: 'my-app',
-        template: "<h1>Hello {{name}}</h1>",
-      })
-      export class AppComponent  {
-        name = 'Angular';
-
-        @MyValidationDecorator( TypeEnum.type, ValidationFunction({option: 'value'}))
-        myClassProp: number;
-    }`;
-    init(data);
-    const appComponent = reflector.getStaticSymbol(file, 'AppComponent');
-    expect(() => reflector.propMetadata(appComponent)).not.toThrow();
-  });
-
-  describe('inheritance', () => {
-    class ClassDecorator {
-      constructor(public value: any) {}
-    }
-
-    class ParamDecorator {
-      constructor(public value: any) {}
-    }
-
-    class PropDecorator {
-      constructor(public value: any) {}
-    }
-
-    function initWithDecorator(testData: {[key: string]: any}) {
-      testData['/tmp/src/decorator.ts'] = `
-            export function ClassDecorator(): any {}
-            export function ParamDecorator(): any {}
-            export function PropDecorator(): any {}
-      `;
-      init(testData, [
-        {filePath: '/tmp/src/decorator.ts', name: 'ClassDecorator', ctor: ClassDecorator},
-        {filePath: '/tmp/src/decorator.ts', name: 'ParamDecorator', ctor: ParamDecorator},
-        {filePath: '/tmp/src/decorator.ts', name: 'PropDecorator', ctor: PropDecorator}
-      ]);
-    }
-
-    it('should inherit annotations', () => {
-      initWithDecorator({
-        '/tmp/src/main.ts': `
-            import {ClassDecorator} from './decorator';
-
-            @ClassDecorator('parent')
-            export class Parent {}
-
-            @ClassDecorator('child')
-            export class Child extends Parent {}
-
-            export class ChildNoDecorators extends Parent {}
-          `
-      });
-
-      // Check that metadata for Parent was not changed!
-      expect(reflector.annotations(reflector.getStaticSymbol('/tmp/src/main.ts', 'Parent')))
-          .toEqual([new ClassDecorator('parent')]);
-
-      expect(reflector.annotations(reflector.getStaticSymbol('/tmp/src/main.ts', 'Child')))
-          .toEqual([new ClassDecorator('parent'), new ClassDecorator('child')]);
-
-      expect(
-          reflector.annotations(reflector.getStaticSymbol('/tmp/src/main.ts', 'ChildNoDecorators')))
-          .toEqual([new ClassDecorator('parent')]);
-    });
-
-    it('should inherit parameters', () => {
-      initWithDecorator({
-        '/tmp/src/main.ts': `
-            import {ParamDecorator} from './decorator';
-
-            export class A {}
-            export class B {}
-            export class C {}
-
-            export class Parent {
-              constructor(@ParamDecorator('a') a: A, @ParamDecorator('b') b: B) {}
-            }
-
-            export class Child extends Parent {}
-
-            export class ChildWithCtor extends Parent {
-              constructor(@ParamDecorator('c') c: C) {}
-            }
-          `
-      });
-
-      // Check that metadata for Parent was not changed!
-      expect(reflector.parameters(reflector.getStaticSymbol('/tmp/src/main.ts', 'Parent')))
-          .toEqual([
-            [reflector.getStaticSymbol('/tmp/src/main.ts', 'A'), new ParamDecorator('a')],
-            [reflector.getStaticSymbol('/tmp/src/main.ts', 'B'), new ParamDecorator('b')]
-          ]);
-
-      expect(reflector.parameters(reflector.getStaticSymbol('/tmp/src/main.ts', 'Child'))).toEqual([
-        [reflector.getStaticSymbol('/tmp/src/main.ts', 'A'), new ParamDecorator('a')],
-        [reflector.getStaticSymbol('/tmp/src/main.ts', 'B'), new ParamDecorator('b')]
-      ]);
-
-      expect(reflector.parameters(reflector.getStaticSymbol('/tmp/src/main.ts', 'ChildWithCtor')))
-          .toEqual([[reflector.getStaticSymbol('/tmp/src/main.ts', 'C'), new ParamDecorator('c')]]);
-    });
-
-    it('should inherit property metadata', () => {
-      initWithDecorator({
-        '/tmp/src/main.ts': `
-            import {PropDecorator} from './decorator';
-
-            export class A {}
-            export class B {}
-            export class C {}
-
-            export class Parent {
-              @PropDecorator('a')
-              a: A;
-              @PropDecorator('b1')
-              b: B;
-            }
-
-            export class Child extends Parent {
-              @PropDecorator('b2')
-              b: B;
-              @PropDecorator('c')
-              c: C;
-            }
-          `
-      });
-
-      // Check that metadata for Parent was not changed!
-      expect(reflector.propMetadata(reflector.getStaticSymbol('/tmp/src/main.ts', 'Parent')))
-          .toEqual({
-            'a': [new PropDecorator('a')],
-            'b': [new PropDecorator('b1')],
-          });
-
-      expect(reflector.propMetadata(reflector.getStaticSymbol('/tmp/src/main.ts', 'Child')))
-          .toEqual({
-            'a': [new PropDecorator('a')],
-            'b': [new PropDecorator('b1'), new PropDecorator('b2')],
-            'c': [new PropDecorator('c')]
-          });
-    });
-
-    it('should inherit lifecycle hooks', () => {
-      initWithDecorator({
-        '/tmp/src/main.ts': `
-            export class Parent {
-              hook1() {}
-              hook2() {}
-            }
-
-            export class Child extends Parent {
-              hook2() {}
-              hook3() {}
-            }
-          `
-      });
-
-      function hooks(symbol: StaticSymbol, names: string[]): boolean[] {
-        return names.map(name => reflector.hasLifecycleHook(symbol, name));
-      }
-
-      // Check that metadata for Parent was not changed!
-      expect(hooks(reflector.getStaticSymbol('/tmp/src/main.ts', 'Parent'), [
-        'hook1', 'hook2', 'hook3'
-      ])).toEqual([true, true, false]);
-
-      expect(hooks(reflector.getStaticSymbol('/tmp/src/main.ts', 'Child'), [
-        'hook1', 'hook2', 'hook3'
-      ])).toEqual([true, true, true]);
-    });
-  });
-
 });
 
-const DEFAULT_TEST_DATA: {[key: string]: any} = {
-      '/tmp/@angular/common/src/forms-deprecated/directives.d.ts': [{
+class MockReflectorHost implements StaticReflectorHost {
+  private staticTypeCache = new Map<string, StaticSymbol>();
+  private collector = new MetadataCollector();
+
+  constructor() {}
+
+  angularImportLocations() {
+    return {
+      coreDecorators: 'angular2/src/core/metadata',
+      diDecorators: 'angular2/src/core/di/metadata',
+      diMetadata: 'angular2/src/core/di/metadata',
+      diOpaqueToken: 'angular2/src/core/di/opaque_token',
+      animationMetadata: 'angular2/src/core/animation/metadata',
+      provider: 'angular2/src/core/di/provider'
+    };
+  }
+
+  getCanonicalFileName(fileName: string): string { return fileName; }
+
+  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    const cacheKey = `${declarationFile}:${name}${members?'.'+members.join('.'):''}`;
+    let result = this.staticTypeCache.get(cacheKey);
+    if (!result) {
+      result = new StaticSymbol(declarationFile, name, members);
+      this.staticTypeCache.set(cacheKey, result);
+    }
+    return result;
+  }
+
+  // In tests, assume that symbols are not re-exported
+  findDeclaration(modulePath: string, symbolName: string, containingFile?: string): StaticSymbol {
+    function splitPath(path: string): string[] { return path.split(/\/|\\/g); }
+
+    function resolvePath(pathParts: string[]): string {
+      const result: string[] = [];
+      pathParts.forEach((part, index) => {
+        switch (part) {
+          case '':
+          case '.':
+            if (index > 0) return;
+            break;
+          case '..':
+            if (index > 0 && result.length != 0) result.pop();
+            return;
+        }
+        result.push(part);
+      });
+      return result.join('/');
+    }
+
+    function pathTo(from: string, to: string): string {
+      let result = to;
+      if (to.startsWith('.')) {
+        const fromParts = splitPath(from);
+        fromParts.pop();  // remove the file name.
+        const toParts = splitPath(to);
+        result = resolvePath(fromParts.concat(toParts));
+      }
+      return result;
+    }
+
+    if (modulePath.indexOf('.') === 0) {
+      const baseName = pathTo(containingFile, modulePath);
+      const tsName = baseName + '.ts';
+      if (this.getMetadataFor(tsName)) {
+        return this.getStaticSymbol(tsName, symbolName);
+      }
+      return this.getStaticSymbol(baseName + '.d.ts', symbolName);
+    }
+    return this.getStaticSymbol('/tmp/' + modulePath + '.d.ts', symbolName);
+  }
+
+  getMetadataFor(moduleId: string): any {
+    const data: {[key: string]: any} = {
+      '/tmp/angular2/src/common/forms-deprecated/directives.d.ts': [{
         '__symbolic': 'module',
-        'version': 3,
+        'version': 1,
         'metadata': {
           'FORM_DIRECTIVES': [
             {
               '__symbolic': 'reference',
               'name': 'NgFor',
-              'module': '@angular/common/src/directives/ng_for'
+              'module': 'angular2/src/common/directives/ng_for'
             }
           ]
         }
       }],
-      '/tmp/@angular/common/src/directives/ng_for.d.ts': {
+      '/tmp/angular2/src/common/directives/ng_for.d.ts': {
         '__symbolic': 'module',
-        'version': 3,
+        'version': 1,
         'metadata': {
           'NgFor': {
             '__symbolic': 'class',
@@ -671,7 +564,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                 'expression': {
                   '__symbolic': 'reference',
                   'name': 'Directive',
-                  'module': '@angular/core/src/metadata'
+                  'module': '../../core/metadata'
                 },
                 'arguments': [
                   {
@@ -688,22 +581,22 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                   'parameters': [
                     {
                       '__symbolic': 'reference',
-                      'module': '@angular/core/src/linker/view_container_ref',
+                      'module': '../../core/linker/view_container_ref',
                       'name': 'ViewContainerRef'
                     },
                     {
                       '__symbolic': 'reference',
-                      'module': '@angular/core/src/linker/template_ref',
+                      'module': '../../core/linker/template_ref',
                       'name': 'TemplateRef'
                     },
                     {
                       '__symbolic': 'reference',
-                      'module': '@angular/core/src/change_detection/differs/iterable_differs',
+                      'module': '../../core/change_detection/differs/iterable_differs',
                       'name': 'IterableDiffers'
                     },
                     {
                       '__symbolic': 'reference',
-                      'module': '@angular/core/src/change_detection/change_detector_ref',
+                      'module': '../../core/change_detection/change_detector_ref',
                       'name': 'ChangeDetectorRef'
                     }
                   ]
@@ -713,17 +606,17 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
           }
         }
       },
-      '/tmp/@angular/core/src/linker/view_container_ref.d.ts':
-          {version: 3, 'metadata': {'ViewContainerRef': {'__symbolic': 'class'}}},
-      '/tmp/@angular/core/src/linker/template_ref.d.ts':
-          {version: 3, 'module': './template_ref', 'metadata': {'TemplateRef': {'__symbolic': 'class'}}},
-      '/tmp/@angular/core/src/change_detection/differs/iterable_differs.d.ts':
-          {version: 3, 'metadata': {'IterableDiffers': {'__symbolic': 'class'}}},
-      '/tmp/@angular/core/src/change_detection/change_detector_ref.d.ts':
-          {version: 3, 'metadata': {'ChangeDetectorRef': {'__symbolic': 'class'}}},
+      '/tmp/angular2/src/core/linker/view_container_ref.d.ts':
+          {version: 1, 'metadata': {'ViewContainerRef': {'__symbolic': 'class'}}},
+      '/tmp/angular2/src/core/linker/template_ref.d.ts':
+          {version: 1, 'module': './template_ref', 'metadata': {'TemplateRef': {'__symbolic': 'class'}}},
+      '/tmp/angular2/src/core/change_detection/differs/iterable_differs.d.ts':
+          {version: 1, 'metadata': {'IterableDiffers': {'__symbolic': 'class'}}},
+      '/tmp/angular2/src/core/change_detection/change_detector_ref.d.ts':
+          {version: 1, 'metadata': {'ChangeDetectorRef': {'__symbolic': 'class'}}},
       '/tmp/src/app/hero-detail.component.d.ts': {
         '__symbolic': 'module',
-        'version': 3,
+        'version': 1,
         'metadata': {
           'HeroDetailComponent': {
             '__symbolic': 'class',
@@ -733,7 +626,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                 'expression': {
                   '__symbolic': 'reference',
                   'name': 'Component',
-                  'module': '@angular/core/src/metadata'
+                  'module': 'angular2/src/core/metadata'
                 },
                 'arguments': [
                   {
@@ -745,7 +638,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                       'expression': {
                         '__symbolic': 'reference',
                         'name': 'trigger',
-                        'module': '@angular/core/src/animation/metadata'
+                        'module': 'angular2/src/core/animation/metadata'
                       },
                       'arguments': [
                         'myAnimation',
@@ -753,7 +646,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                            'expression': {
                              '__symbolic': 'reference',
                              'name': 'state',
-                             'module': '@angular/core/src/animation/metadata'
+                             'module': 'angular2/src/core/animation/metadata'
                            },
                            'arguments': [
                              'state1',
@@ -761,7 +654,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                                 'expression': {
                                   '__symbolic': 'reference',
                                   'name': 'style',
-                                  'module': '@angular/core/src/animation/metadata'
+                                  'module': 'angular2/src/core/animation/metadata'
                                 },
                                 'arguments': [
                                   { 'background':'white' }
@@ -773,7 +666,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                             'expression': {
                               '__symbolic':'reference',
                               'name':'transition',
-                              'module': '@angular/core/src/animation/metadata'
+                              'module': 'angular2/src/core/animation/metadata'
                             },
                             'arguments': [
                               '* => *',
@@ -782,20 +675,20 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                                 'expression':{
                                   '__symbolic':'reference',
                                   'name':'sequence',
-                                  'module': '@angular/core/src/animation/metadata'
+                                  'module': 'angular2/src/core/animation/metadata'
                                 },
                                 'arguments':[[{ '__symbolic': 'call',
                                   'expression': {
                                     '__symbolic':'reference',
                                     'name':'group',
-                                    'module': '@angular/core/src/animation/metadata'
+                                    'module': 'angular2/src/core/animation/metadata'
                                   },
                                   'arguments':[[{
                                     '__symbolic': 'call',
                                     'expression': {
                                       '__symbolic':'reference',
                                       'name':'animate',
-                                      'module': '@angular/core/src/animation/metadata'
+                                      'module': 'angular2/src/core/animation/metadata'
                                     },
                                     'arguments':[
                                       '1s 0.5s',
@@ -803,13 +696,13 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                                         'expression': {
                                           '__symbolic':'reference',
                                           'name':'keyframes',
-                                          'module': '@angular/core/src/animation/metadata'
+                                          'module': 'angular2/src/core/animation/metadata'
                                         },
                                         'arguments':[[{ '__symbolic': 'call',
                                           'expression': {
                                             '__symbolic':'reference',
                                             'name':'style',
-                                            'module': '@angular/core/src/animation/metadata'
+                                            'module': 'angular2/src/core/animation/metadata'
                                           },
                                           'arguments':[ { 'background': 'blue'} ]
                                         }, {
@@ -817,7 +710,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                                           'expression': {
                                             '__symbolic':'reference',
                                             'name':'style',
-                                            'module': '@angular/core/src/animation/metadata'
+                                            'module': 'angular2/src/core/animation/metadata'
                                           },
                                           'arguments':[ { 'background': 'red'} ]
                                         }]]
@@ -843,7 +736,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                       'expression': {
                         '__symbolic': 'reference',
                         'name': 'Input',
-                        'module': '@angular/core/src/metadata'
+                        'module': 'angular2/src/core/metadata'
                       }
                     }
                   ]
@@ -857,7 +750,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                                 '__symbolic': 'call',
                                 'expression': {
                                     '__symbolic': 'reference',
-                                    'module': '@angular/core/src/metadata',
+                                    'module': 'angular2/src/core/metadata',
                                     'name': 'HostListener'
                                 },
                                 'arguments': [
@@ -874,10 +767,11 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
           }
         }
       },
-      '/src/extern.d.ts': {'__symbolic': 'module', 'version': 3, metadata: {s: 's'}},
+      '/src/extern.d.ts': {'__symbolic': 'module', 'version': 1, metadata: {s: 's'}},
+      '/tmp/src/version-error.d.ts': {'__symbolic': 'module', 'version': 100, metadata: {e: 's'}},
       '/tmp/src/error-reporting.d.ts': {
         __symbolic: 'module',
-        version: 3,
+        version: 1,
         metadata: {
           SomeClass: {
             __symbolic: 'class',
@@ -887,7 +781,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
                 expression: {
                   __symbolic: 'reference',
                   name: 'Component',
-                  module: '@angular/core/src/metadata'
+                  module: 'angular2/src/core/metadata'
                 },
                 arguments: [
                   {
@@ -907,7 +801,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       },
       '/tmp/src/error-references.d.ts': {
         __symbolic: 'module',
-        version: 3,
+        version: 1,
         metadata: {
           Link1: {
             __symbolic: 'reference',
@@ -929,7 +823,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       },
       '/tmp/src/function-declaration.d.ts': {
         __symbolic: 'module',
-        version: 3,
+        version: 1,
         metadata: {
           one: {
             __symbolic: 'function',
@@ -958,7 +852,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       },
       '/tmp/src/function-reference.ts': {
         __symbolic: 'module',
-        version: 3,
+        version: 1,
         metadata: {
           one: {
             __symbolic: 'call',
@@ -1000,7 +894,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       },
       '/tmp/src/function-recursive.d.ts': {
         __symbolic: 'modules',
-        version: 3,
+        version: 1,
         metadata: {
           recursive: {
             __symbolic: 'function',
@@ -1060,7 +954,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       },
       '/tmp/src/spread.ts': {
         __symbolic: 'module',
-        version: 3,
+        version: 1,
         metadata: {
           spread: [0, {__symbolic: 'spread', expression: [1, 2, 3, 4]}, 5]
         }
@@ -1088,8 +982,8 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
       `,
       '/tmp/src/invalid-calls.ts': `
         import {someFunction} from './nvalid-calll-definitions.ts';
-        import {Component} from '@angular/core/src/metadata';
-        import {NgIf} from '@angular/common';
+        import {Component} from 'angular2/src/core/metadata';
+        import {NgIf} from 'angular2/common';
 
         @Component({
           selector: 'my-component',
@@ -1105,7 +999,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         export class MyOtherComponent { }
       `,
       '/tmp/src/static-method.ts': `
-        import {Component} from '@angular/core/src/metadata';
+        import {Component} from 'angular2/src/core/metadata';
 
         @Component({
           selector: 'stub'
@@ -1120,19 +1014,10 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
           static defaultsMethod(a, b = true, c = false) {
             return [a, b, c];
           }
-          static withFactory() {
-            return { provide: 'c', useFactory: AnotherModule.someFactory };
-          }
-        }
-
-        export class AnotherModule {
-          static someFactory() {
-            return 'e';
-          }
         }
       `,
       '/tmp/src/static-method-call.ts': `
-        import {Component} from '@angular/core/src/metadata';
+        import {Component} from 'angular2/src/core/metadata';
         import {MyModule} from './static-method';
 
         @Component({
@@ -1149,14 +1034,9 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
           providers: [MyModule.defaultsMethod('a')]
         })
         export class MyDefaultsComponent { }
-
-        @Component({
-          providers: MyModule.withFactory()
-        })
-        export class MyFactoryComponent { }
       `,
       '/tmp/src/static-field.ts': `
-        import {Injectable} from '@angular/core';
+        import {Injectable} from 'angular2/core';
 
         @Injectable()
         export class MyModule {
@@ -1164,7 +1044,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         }
       `,
       '/tmp/src/static-field-reference.ts': `
-        import {Component} from '@angular/core/src/metadata';
+        import {Component} from 'angular2/src/core/metadata';
         import {MyModule} from './static-field';
 
         @Component({
@@ -1178,7 +1058,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         }
       `,
       '/tmp/src/static-method-ref.ts': `
-        import {Component} from '@angular/core/src/metadata';
+        import {Component} from 'angular2/src/core/metadata';
         import {ClassWithStatics} from './static-method-def';
 
         @Component({
@@ -1189,7 +1069,7 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         }
       `,
       '/tmp/src/invalid-metadata.ts': `
-        import {Component} from '@angular/core/src/metadata';
+        import {Component} from 'angular2/src/core/metadata';
 
         @Component({
           providers: [ { provider: 'a', useValue: (() => 1)() }]
@@ -1197,9 +1077,9 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         export class InvalidMetadata {}
       `,
       '/tmp/src/forward-ref.ts': `
-        import {forwardRef} from '@angular/core';
-        import {Component} from '@angular/core/src/metadata';
-        import {Inject} from '@angular/core/src/di/metadata';
+        import {forwardRef} from 'angular2/core';
+        import {Component} from 'angular2/src/core/metadata';
+        import {Inject} from 'angular2/src/core/di/metadata';
         @Component({})
         export class Forward {
           constructor(@Inject(forwardRef(() => Dep)) d: Dep) {}
@@ -1207,5 +1087,22 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         export class Dep {
           @Input f: Forward;
         }
-      `,
+      `
     };
+
+
+    if (data[moduleId] && moduleId.match(TS_EXT)) {
+      const text = data[moduleId];
+      if (typeof text === 'string') {
+        const sf = ts.createSourceFile(
+            moduleId, data[moduleId], ts.ScriptTarget.ES5, /* setParentNodes */ true);
+        const diagnostics: ts.Diagnostic[] = (<any>sf).parseDiagnostics;
+        if (diagnostics && diagnostics.length) {
+          throw Error(`Error encountered during parse of file ${moduleId}`);
+        }
+        return this.collector.getMetadata(sf);
+      }
+    }
+    return data[moduleId];
+  }
+}

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

@@ -1,34 +0,0 @@
-{
-    "compilerOptions": {
-        "baseUrl": ".",
-        "declaration": true,
-        "experimentalDecorators": true,
-        "noImplicitAny": true,
-        "module": "es2015",
-        "moduleResolution": "node",
-        "outDir": "../../../dist/esm/compiler-cli",
-        "paths": {
-          "@angular/core": ["../../../dist/packages-dist/core"],
-          "@angular/common": ["../../../dist/packages-dist/common"],
-          "@angular/compiler": ["../../../dist/packages-dist/compiler"],
-          "@angular/platform-server": ["../../../dist/packages-dist/platform-server"],
-          "@angular/platform-browser": ["../../../dist/packages-dist/platform-browser"],
-          "@angular/tsc-wrapped": ["../../../dist/tools/@angular/tsc-wrapped"]
-        },
-        "rootDir": ".",
-        "sourceMap": true,
-        "inlineSources": true,
-        "target": "es5",
-        "lib": ["es6", "dom"],
-        "skipLibCheck": true
-    },
-    "exclude": ["integrationtest"],
-    "files": [
-        "index.ts",
-        "src/main.ts",
-        "src/extract_i18n.ts",
-        "../../../node_modules/@types/node/index.d.ts",
-        "../../../node_modules/@types/jasmine/index.d.ts",
-        "../../../node_modules/zone.js/dist/zone.js.d.ts"
-    ]
-}

modules/@angular/compiler/index.ts

@@ -21,24 +21,15 @@
  *   </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';
 export * from './src/compile_metadata';
-export * from './src/aot/compiler_factory';
-export * from './src/aot/compiler';
-export * from './src/aot/compiler_host';
-export * from './src/aot/static_reflector';
-export * from './src/aot/static_reflection_capabilities';
-export * from './src/aot/static_symbol';
-export * from './src/aot/static_symbol_resolver';
-export * from './src/aot/summary_resolver';
-export * from './src/summary_resolver';
-export {JitCompiler} from './src/jit/compiler';
-export * from './src/jit/compiler_factory';
+export * from './src/offline_compiler';
+export {RuntimeCompiler} from './src/runtime_compiler';
 export * from './src/url_resolver';
 export * from './src/resource_loader';
+export * from './src/compiler';
 export {DirectiveResolver} from './src/directive_resolver';
 export {PipeResolver} from './src/pipe_resolver';
 export {NgModuleResolver} from './src/ng_module_resolver';
@@ -62,5 +53,5 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
-export {SyntaxError} from './src/util';
+
 // This file only reexports content of the `src` folder. Keep it that way.

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

@@ -8,7 +8,7 @@
 
 
 import {isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ANY_STATE, DEFAULT_STATE, EMPTY_STATE} from '../private_import_core';
 
@@ -66,11 +66,11 @@ class _AnimationBuilder implements AnimationAstVisitor {
     ast.styles.forEach(entry => {
       const entries =
           Object.keys(entry).map((key): [string, o.Expression] => [key, o.literal(entry[key])]);
-      stylesArr.push(o.literalMap(entries, null, true));
+      stylesArr.push(o.literalMap(entries));
     });
 
-    return o.importExpr(createIdentifier(Identifiers.AnimationStyles)).instantiate([
-      o.importExpr(createIdentifier(Identifiers.collectAndResolveStyles)).callFn([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationStyles)).instantiate([
+      o.importExpr(resolveIdentifier(Identifiers.collectAndResolveStyles)).callFn([
         _ANIMATION_COLLECTED_STYLES, o.literalArr(stylesArr)
       ])
     ]);
@@ -78,7 +78,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
 
   visitAnimationKeyframe(ast: AnimationKeyframeAst, context: _AnimationBuilderContext):
       o.Expression {
-    return o.importExpr(createIdentifier(Identifiers.AnimationKeyframe)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationKeyframe)).instantiate([
       o.literal(ast.offset), ast.styles.visit(this, context)
     ]);
   }
@@ -100,7 +100,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     const startingStylesExpr = ast.startingStyles.visit(this, context);
     const keyframeExpressions = ast.keyframes.map(keyframe => keyframe.visit(this, context));
     const keyframesExpr =
-        o.importExpr(createIdentifier(Identifiers.balanceAnimationKeyframes)).callFn([
+        o.importExpr(resolveIdentifier(Identifiers.balanceAnimationKeyframes)).callFn([
           _ANIMATION_COLLECTED_STYLES, _ANIMATION_END_STATE_STYLES_VAR,
           o.literalArr(keyframeExpressions)
         ]);
@@ -127,14 +127,14 @@ class _AnimationBuilder implements AnimationAstVisitor {
   visitAnimationSequence(ast: AnimationSequenceAst, context: _AnimationBuilderContext):
       o.Expression {
     const playerExprs = ast.steps.map(step => step.visit(this, context));
-    return o.importExpr(createIdentifier(Identifiers.AnimationSequencePlayer)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationSequencePlayer)).instantiate([
       o.literalArr(playerExprs)
     ]);
   }
 
   visitAnimationGroup(ast: AnimationGroupAst, context: _AnimationBuilderContext): o.Expression {
     const playerExprs = ast.steps.map(step => step.visit(this, context));
-    return o.importExpr(createIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
+    return o.importExpr(resolveIdentifier(Identifiers.AnimationGroupPlayer)).instantiate([
       o.literalArr(playerExprs)
     ]);
   }
@@ -199,9 +199,8 @@ class _AnimationBuilder implements AnimationAstVisitor {
                         .set(_ANIMATION_FACTORY_VIEW_CONTEXT.callMethod(
                             'getAnimationPlayers',
                             [
-                              _ANIMATION_FACTORY_ELEMENT_VAR,
+                              _ANIMATION_FACTORY_ELEMENT_VAR, o.literal(this.animationName),
                               _ANIMATION_NEXT_STATE_VAR.equals(o.literal(EMPTY_STATE))
-                                  .conditional(o.NULL_EXPR, o.literal(this.animationName))
                             ]))
                         .toDeclStmt());
 
@@ -229,7 +228,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
         _ANIMATION_END_STATE_STYLES_VAR.equals(o.NULL_EXPR),
         [_ANIMATION_END_STATE_STYLES_VAR.set(_ANIMATION_DEFAULT_STATE_VAR).toStmt()]));
 
-    const RENDER_STYLES_FN = o.importExpr(createIdentifier(Identifiers.renderStyles));
+    const RENDER_STYLES_FN = o.importExpr(resolveIdentifier(Identifiers.renderStyles));
 
     ast.stateTransitions.forEach(transAst => statements.push(transAst.visit(this, context)));
 
@@ -238,7 +237,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     statements.push(new o.IfStmt(
         _ANIMATION_PLAYER_VAR.equals(o.NULL_EXPR),
         [_ANIMATION_PLAYER_VAR
-             .set(o.importExpr(createIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
+             .set(o.importExpr(resolveIdentifier(Identifiers.NoOpAnimationPlayer)).instantiate([]))
              .toStmt()]));
 
     // once complete we want to apply the styles on the element
@@ -256,18 +255,17 @@ class _AnimationBuilder implements AnimationAstVisitor {
                                .callFn([
                                  _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
                                  o.importExpr(
-                                      createIdentifier(Identifiers.prepareFinalAnimationStyles))
-                                     .callFn(
-                                         [
-                                           _ANIMATION_START_STATE_STYLES_VAR,
-                                           _ANIMATION_END_STATE_STYLES_VAR
-                                         ])
+                                      resolveIdentifier(Identifiers.prepareFinalAnimationStyles))
+                                     .callFn([
+                                       _ANIMATION_START_STATE_STYLES_VAR,
+                                       _ANIMATION_END_STATE_STYLES_VAR
+                                     ])
                                ])
                                .toStmt()
                          ])])
             .toStmt());
 
-    statements.push(o.importExpr(createIdentifier(Identifiers.AnimationSequencePlayer))
+    statements.push(o.importExpr(resolveIdentifier(Identifiers.AnimationSequencePlayer))
                         .instantiate([_PREVIOUS_ANIMATION_PLAYERS])
                         .callMethod('destroy', [])
                         .toStmt());
@@ -278,7 +276,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     statements.push(RENDER_STYLES_FN
                         .callFn([
                           _ANIMATION_FACTORY_ELEMENT_VAR, _ANIMATION_FACTORY_RENDERER_VAR,
-                          o.importExpr(createIdentifier(Identifiers.clearStyles))
+                          o.importExpr(resolveIdentifier(Identifiers.clearStyles))
                               .callFn([_ANIMATION_START_STATE_STYLES_VAR])
                         ])
                         .toStmt());
@@ -293,7 +291,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
                         .toStmt());
 
     statements.push(new o.ReturnStatement(
-        o.importExpr(createIdentifier(Identifiers.AnimationTransition)).instantiate([
+        o.importExpr(resolveIdentifier(Identifiers.AnimationTransition)).instantiate([
           _ANIMATION_PLAYER_VAR, _ANIMATION_CURRENT_STATE_VAR, _ANIMATION_NEXT_STATE_VAR,
           _ANIMATION_TIME_VAR
         ])));
@@ -302,12 +300,12 @@ class _AnimationBuilder implements AnimationAstVisitor {
         [
           new o.FnParam(
               _ANIMATION_FACTORY_VIEW_VAR.name,
-              o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+              o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
           new o.FnParam(_ANIMATION_FACTORY_ELEMENT_VAR.name, o.DYNAMIC_TYPE),
           new o.FnParam(_ANIMATION_CURRENT_STATE_VAR.name, o.DYNAMIC_TYPE),
           new o.FnParam(_ANIMATION_NEXT_STATE_VAR.name, o.DYNAMIC_TYPE)
         ],
-        statements, o.importType(createIdentifier(Identifiers.AnimationTransition)));
+        statements, o.importType(resolveIdentifier(Identifiers.AnimationTransition)));
   }
 
   build(ast: AnimationAst): AnimationEntryCompileResult {
@@ -322,13 +320,12 @@ class _AnimationBuilder implements AnimationAstVisitor {
       if (isPresent(value)) {
         const styleMap: any[] = [];
         Object.keys(value).forEach(key => { styleMap.push([key, o.literal(value[key])]); });
-        variableValue = o.literalMap(styleMap, null, true);
+        variableValue = o.literalMap(styleMap);
       }
       lookupMap.push([stateName, variableValue]);
     });
 
-    const compiledStatesMapStmt =
-        this._statesMapVar.set(o.literalMap(lookupMap, null, true)).toDeclStmt();
+    const compiledStatesMapStmt = this._statesMapVar.set(o.literalMap(lookupMap)).toDeclStmt();
     const statements: o.Statement[] = [compiledStatesMapStmt, fnStatement];
 
     return new AnimationEntryCompileResult(this.animationName, statements, fnVariable);

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

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata, identifierName} from '../compile_metadata';
+import {Injectable} from '@angular/core';
+
+import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata} from '../compile_metadata';
 import {StringMapWrapper} from '../facade/collection';
 import {isBlank, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {ParseError} from '../parse_util';
 import {ANY_STATE, FILL_STYLE_FLAG} from '../private_import_core';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
@@ -34,13 +35,13 @@ export class AnimationEntryParseResult {
   constructor(public ast: AnimationEntryAst, public errors: AnimationParseError[]) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class AnimationParser {
   constructor(private _schema: ElementSchemaRegistry) {}
 
   parseComponent(component: CompileDirectiveMetadata): AnimationEntryAst[] {
     const errors: string[] = [];
-    const componentName = identifierName(component.type);
+    const componentName = component.type.name;
     const animationTriggerNames = new Set<string>();
     const asts = component.template.animations.map(entry => {
       const result = this.parseEntry(entry);
@@ -173,11 +174,6 @@ function _normalizeStyleMetadata(
     entry: CompileAnimationStyleMetadata, stateStyles: {[key: string]: AnimationStylesAst},
     schema: ElementSchemaRegistry, errors: AnimationParseError[],
     permitStateReferences: boolean): {[key: string]: string | number}[] {
-  const offset = entry.offset;
-  if (offset > 1 || offset < 0) {
-    errors.push(new AnimationParseError(`Offset values for animations must be between 0 and 1`));
-  }
-
   const normalizedStyles: {[key: string]: string | number}[] = [];
   entry.styles.forEach(styleEntry => {
     if (typeof styleEntry === 'string') {

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

@@ -1,81 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {ViewEncapsulation} from '@angular/core';
-
-import {AnimationParser} from '../animation/animation_parser';
-import {CompilerConfig} from '../config';
-import {DirectiveNormalizer} from '../directive_normalizer';
-import {DirectiveResolver} from '../directive_resolver';
-import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
-import {Lexer} from '../expression_parser/lexer';
-import {Parser} from '../expression_parser/parser';
-import {I18NHtmlParser} from '../i18n/i18n_html_parser';
-import {CompileMetadataResolver} from '../metadata_resolver';
-import {HtmlParser} from '../ml_parser/html_parser';
-import {NgModuleCompiler} from '../ng_module_compiler';
-import {NgModuleResolver} from '../ng_module_resolver';
-import {TypeScriptEmitter} from '../output/ts_emitter';
-import {PipeResolver} from '../pipe_resolver';
-import {Console} from '../private_import_core';
-import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
-import {StyleCompiler} from '../style_compiler';
-import {TemplateParser} from '../template_parser/template_parser';
-import {createOfflineCompileUrlResolver} from '../url_resolver';
-import {ViewCompiler} from '../view_compiler/view_compiler';
-
-import {AotCompiler} from './compiler';
-import {AotCompilerHost} from './compiler_host';
-import {AotCompilerOptions} from './compiler_options';
-import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
-import {StaticReflector} from './static_reflector';
-import {StaticSymbolCache} from './static_symbol';
-import {StaticSymbolResolver} from './static_symbol_resolver';
-import {AotSummaryResolver} from './summary_resolver';
-
-
-/**
- * Creates a new AotCompiler based on options and a host.
- */
-export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCompilerOptions):
-    {compiler: AotCompiler, reflector: StaticReflector} {
-  let translations: string = options.translations || '';
-
-  const urlResolver = createOfflineCompileUrlResolver();
-  const symbolCache = new StaticSymbolCache();
-  const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
-  const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
-  const staticReflector = new StaticReflector(symbolResolver);
-  StaticAndDynamicReflectionCapabilities.install(staticReflector);
-  const htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat);
-  const config = new CompilerConfig({
-    genDebugInfo: options.debug === true,
-    defaultEncapsulation: ViewEncapsulation.Emulated,
-    logBindingUpdate: false,
-    useJit: false
-  });
-  const normalizer = new DirectiveNormalizer(
-      {get: (url: string) => compilerHost.loadResource(url)}, urlResolver, htmlParser, config);
-  const expressionParser = new Parser(new Lexer());
-  const elementSchemaRegistry = new DomElementSchemaRegistry();
-  const console = new Console();
-  const tmplParser =
-      new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
-  const resolver = new CompileMetadataResolver(
-      new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-      new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-      staticReflector);
-  // TODO(vicb): do not pass options.i18nFormat here
-  const compiler = new AotCompiler(
-      compilerHost, resolver, tmplParser, new StyleCompiler(urlResolver),
-      new ViewCompiler(config, elementSchemaRegistry),
-      new DirectiveWrapperCompiler(config, expressionParser, elementSchemaRegistry, console),
-      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), summaryResolver, options.locale,
-      options.i18nFormat, new AnimationParser(elementSchemaRegistry), symbolResolver);
-  return {compiler, reflector: staticReflector};
-}

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

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {ImportResolver} from '../output/path_util';
-
-import {StaticSymbol} from './static_symbol';
-import {StaticSymbolResolverHost} from './static_symbol_resolver';
-import {AotSummaryResolverHost} from './summary_resolver';
-import {AotSummarySerializerHost} from './summary_serializer';
-
-/**
- * The host of the AotCompiler disconnects the implementation from TypeScript / other language
- * services and from underlying file systems.
- */
-export interface AotCompilerHost extends StaticSymbolResolverHost, ImportResolver,
-    AotSummaryResolverHost, AotSummarySerializerHost {
-  /**
-   * Loads a resource (e.g. html / css)
-   */
-  loadResource(path: string): Promise<string>;
-}

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

@@ -1,14 +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 interface AotCompilerOptions {
-  debug?: boolean;
-  locale?: string;
-  i18nFormat?: string;
-  translations?: string;
-}

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

@@ -1,665 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Attribute, Component, ContentChild, ContentChildren, Directive, Host, HostBinding, HostListener, Inject, Injectable, Input, NgModule, Optional, Output, Pipe, Self, SkipSelf, ViewChild, ViewChildren, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
-
-import {ReflectorReader} from '../private_import_core';
-
-import {StaticSymbol} from './static_symbol';
-import {StaticSymbolResolver} from './static_symbol_resolver';
-
-const ANGULAR_IMPORT_LOCATIONS = {
-  coreDecorators: '@angular/core/src/metadata',
-  diDecorators: '@angular/core/src/di/metadata',
-  diMetadata: '@angular/core/src/di/metadata',
-  diOpaqueToken: '@angular/core/src/di/opaque_token',
-  animationMetadata: '@angular/core/src/animation/metadata',
-  provider: '@angular/core/src/di/provider'
-};
-
-const HIDDEN_KEY = /^\$.*\$$/;
-
-/**
- * A static reflector implements enough of the Reflector API that is necessary to compile
- * templates statically.
- */
-export class StaticReflector implements ReflectorReader {
-  private annotationCache = new Map<StaticSymbol, any[]>();
-  private propertyCache = new Map<StaticSymbol, {[key: string]: any[]}>();
-  private parameterCache = new Map<StaticSymbol, any[]>();
-  private methodCache = new Map<StaticSymbol, {[key: string]: boolean}>();
-  private conversionMap = new Map<StaticSymbol, (context: StaticSymbol, args: any[]) => any>();
-  private opaqueToken: StaticSymbol;
-
-  constructor(
-      private symbolResolver: StaticSymbolResolver,
-      knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
-      knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
-      private errorRecorder?: (error: any, fileName: string) => void) {
-    this.initializeConversionMap();
-    knownMetadataClasses.forEach(
-        (kc) => this._registerDecoratorOrConstructor(
-            this.getStaticSymbol(kc.filePath, kc.name), kc.ctor));
-    knownMetadataFunctions.forEach(
-        (kf) => this._registerFunction(this.getStaticSymbol(kf.filePath, kf.name), kf.fn));
-  }
-
-  importUri(typeOrFunc: StaticSymbol): string {
-    const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
-    return staticSymbol ? staticSymbol.filePath : null;
-  }
-
-  resolveIdentifier(name: string, moduleUrl: string): StaticSymbol {
-    return this.findDeclaration(moduleUrl, name);
-  }
-
-  findDeclaration(moduleUrl: string, name: string, containingFile?: string): StaticSymbol {
-    return this.findSymbolDeclaration(
-        this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile));
-  }
-
-  findSymbolDeclaration(symbol: StaticSymbol): StaticSymbol {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);
-    if (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
-      return this.findSymbolDeclaration(resolvedSymbol.metadata);
-    } else {
-      return symbol;
-    }
-  }
-
-  resolveEnum(enumIdentifier: any, name: string): any {
-    const staticSymbol: StaticSymbol = enumIdentifier;
-    return this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name, [name]);
-  }
-
-  public annotations(type: StaticSymbol): any[] {
-    let annotations = this.annotationCache.get(type);
-    if (!annotations) {
-      annotations = [];
-      const classMetadata = this.getTypeMetadata(type);
-      if (classMetadata['extends']) {
-        const parentAnnotations = this.annotations(this.simplify(type, classMetadata['extends']));
-        annotations.push(...parentAnnotations);
-      }
-      if (classMetadata['decorators']) {
-        const ownAnnotations: any[] = this.simplify(type, classMetadata['decorators']);
-        annotations.push(...ownAnnotations);
-      }
-      this.annotationCache.set(type, annotations.filter(ann => !!ann));
-    }
-    return annotations;
-  }
-
-  public propMetadata(type: StaticSymbol): {[key: string]: any[]} {
-    let propMetadata = this.propertyCache.get(type);
-    if (!propMetadata) {
-      const classMetadata = this.getTypeMetadata(type);
-      propMetadata = {};
-      if (classMetadata['extends']) {
-        const parentPropMetadata = this.propMetadata(this.simplify(type, classMetadata['extends']));
-        Object.keys(parentPropMetadata).forEach((parentProp) => {
-          propMetadata[parentProp] = parentPropMetadata[parentProp];
-        });
-      }
-
-      const members = classMetadata['members'] || {};
-      Object.keys(members).forEach((propName) => {
-        const propData = members[propName];
-        const prop = (<any[]>propData)
-                         .find(a => a['__symbolic'] == 'property' || a['__symbolic'] == 'method');
-        const decorators: any[] = [];
-        if (propMetadata[propName]) {
-          decorators.push(...propMetadata[propName]);
-        }
-        propMetadata[propName] = decorators;
-        if (prop && prop['decorators']) {
-          decorators.push(...this.simplify(type, prop['decorators']));
-        }
-      });
-      this.propertyCache.set(type, propMetadata);
-    }
-    return propMetadata;
-  }
-
-  public parameters(type: StaticSymbol): any[] {
-    if (!(type instanceof StaticSymbol)) {
-      this.reportError(
-          new Error(`parameters received ${JSON.stringify(type)} which is not a StaticSymbol`),
-          type);
-      return [];
-    }
-    try {
-      let parameters = this.parameterCache.get(type);
-      if (!parameters) {
-        const classMetadata = this.getTypeMetadata(type);
-        const members = classMetadata ? classMetadata['members'] : null;
-        const ctorData = members ? members['__ctor__'] : null;
-        if (ctorData) {
-          const ctor = (<any[]>ctorData).find(a => a['__symbolic'] == 'constructor');
-          const parameterTypes = <any[]>this.simplify(type, ctor['parameters'] || []);
-          const parameterDecorators = <any[]>this.simplify(type, ctor['parameterDecorators'] || []);
-          parameters = [];
-          parameterTypes.forEach((paramType, index) => {
-            const nestedResult: any[] = [];
-            if (paramType) {
-              nestedResult.push(paramType);
-            }
-            const decorators = parameterDecorators ? parameterDecorators[index] : null;
-            if (decorators) {
-              nestedResult.push(...decorators);
-            }
-            parameters.push(nestedResult);
-          });
-        } else if (classMetadata['extends']) {
-          parameters = this.parameters(this.simplify(type, classMetadata['extends']));
-        }
-        if (!parameters) {
-          parameters = [];
-        }
-        this.parameterCache.set(type, parameters);
-      }
-      return parameters;
-    } catch (e) {
-      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
-      throw e;
-    }
-  }
-
-  private _methodNames(type: any): {[key: string]: boolean} {
-    let methodNames = this.methodCache.get(type);
-    if (!methodNames) {
-      const classMetadata = this.getTypeMetadata(type);
-      methodNames = {};
-      if (classMetadata['extends']) {
-        const parentMethodNames = this._methodNames(this.simplify(type, classMetadata['extends']));
-        Object.keys(parentMethodNames).forEach((parentProp) => {
-          methodNames[parentProp] = parentMethodNames[parentProp];
-        });
-      }
-
-      const members = classMetadata['members'] || {};
-      Object.keys(members).forEach((propName) => {
-        const propData = members[propName];
-        const isMethod = (<any[]>propData).some(a => a['__symbolic'] == 'method');
-        methodNames[propName] = methodNames[propName] || isMethod;
-      });
-      this.methodCache.set(type, methodNames);
-    }
-    return methodNames;
-  }
-
-  hasLifecycleHook(type: any, lcProperty: string): boolean {
-    if (!(type instanceof StaticSymbol)) {
-      this.reportError(
-          new Error(
-              `hasLifecycleHook received ${JSON.stringify(type)} which is not a StaticSymbol`),
-          type);
-    }
-    try {
-      return !!this._methodNames(type)[lcProperty];
-    } catch (e) {
-      console.error(`Failed on type ${JSON.stringify(type)} with error ${e}`);
-      throw e;
-    }
-  }
-
-  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 {
-    this.conversionMap.set(type, (context: StaticSymbol, args: any[]) => fn.apply(undefined, args));
-  }
-
-  private initializeConversionMap(): void {
-    const {coreDecorators, diDecorators, diMetadata, diOpaqueToken, animationMetadata, provider} =
-        ANGULAR_IMPORT_LOCATIONS;
-    this.opaqueToken = this.findDeclaration(diOpaqueToken, 'OpaqueToken');
-
-    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.findDeclaration(coreDecorators, 'Attribute'), Attribute);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'ContentChild'), ContentChild);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'ContentChildren'), ContentChildren);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'ViewChild'), ViewChild);
-    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.findDeclaration(coreDecorators, 'HostBinding'), HostBinding);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'HostListener'), HostListener);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'Directive'), Directive);
-    this._registerDecoratorOrConstructor(
-        this.findDeclaration(coreDecorators, 'Component'), Component);
-    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._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);
-  }
-
-  /**
-   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
-   * All types passed to the StaticResolver should be pseudo-types returned by this method.
-   *
-   * @param declarationFile the absolute path of the file where the symbol is declared
-   * @param name the name of the type.
-   */
-  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.symbolResolver.getStaticSymbol(declarationFile, name, members);
-  }
-
-  private reportError(error: Error, context: StaticSymbol, path?: string) {
-    if (this.errorRecorder) {
-      this.errorRecorder(error, (context && context.filePath) || path);
-    } else {
-      throw error;
-    }
-  }
-
-  /** @internal */
-  public simplify(context: StaticSymbol, value: any): any {
-    const self = this;
-    let scope = BindingScope.empty;
-    const calling = new Map<StaticSymbol, boolean>();
-
-    function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
-      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        const resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);
-        return resolvedSymbol ? resolvedSymbol.metadata : null;
-      }
-
-      function simplifyCall(functionSymbol: StaticSymbol, targetFunction: any, args: any[]) {
-        if (targetFunction && targetFunction['__symbolic'] == 'function') {
-          if (calling.get(functionSymbol)) {
-            throw new Error('Recursion not supported');
-          }
-          calling.set(functionSymbol, true);
-          try {
-            const value = targetFunction['value'];
-            if (value && (depth != 0 || value.__symbolic != 'error')) {
-              const parameters: string[] = targetFunction['parameters'];
-              const defaults: any[] = targetFunction.defaults;
-              args = args.map(arg => simplifyInContext(context, arg, depth + 1));
-              if (defaults && defaults.length > args.length) {
-                args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
-              }
-              const functionScope = BindingScope.build();
-              for (let i = 0; i < parameters.length; i++) {
-                functionScope.define(parameters[i], args[i]);
-              }
-              const oldScope = scope;
-              let result: any;
-              try {
-                scope = functionScope.done();
-                result = simplifyInContext(functionSymbol, value, depth + 1);
-              } finally {
-                scope = oldScope;
-              }
-              return result;
-            }
-          } finally {
-            calling.delete(functionSymbol);
-          }
-        }
-
-        if (depth === 0) {
-          // If depth is 0 we are evaluating the top level expression that is describing element
-          // decorator. In this case, it is a decorator we don't understand, such as a custom
-          // non-angular decorator, and we should just ignore it.
-          return {__symbolic: 'ignore'};
-        }
-        return simplify(
-            {__symbolic: 'error', message: 'Function call not supported', context: functionSymbol});
-      }
-
-      function simplify(expression: any): any {
-        if (isPrimitive(expression)) {
-          return expression;
-        }
-        if (expression instanceof Array) {
-          const result: any[] = [];
-          for (const item of (<any>expression)) {
-            // Check for a spread expression
-            if (item && item.__symbolic === 'spread') {
-              const spreadArray = simplify(item.expression);
-              if (Array.isArray(spreadArray)) {
-                for (const spreadItem of spreadArray) {
-                  result.push(spreadItem);
-                }
-                continue;
-              }
-            }
-            const value = simplify(item);
-            if (shouldIgnore(value)) {
-              continue;
-            }
-            result.push(value);
-          }
-          return result;
-        }
-        if (expression instanceof StaticSymbol) {
-          // Stop simplification at builtin symbols
-          if (expression === self.opaqueToken || self.conversionMap.has(expression)) {
-            return expression;
-          } else {
-            const staticSymbol = expression;
-            const declarationValue = resolveReferenceValue(staticSymbol);
-            if (declarationValue) {
-              return simplifyInContext(staticSymbol, declarationValue, depth + 1);
-            } else {
-              return staticSymbol;
-            }
-          }
-        }
-        if (expression) {
-          if (expression['__symbolic']) {
-            let staticSymbol: StaticSymbol;
-            switch (expression['__symbolic']) {
-              case 'binop':
-                let left = simplify(expression['left']);
-                if (shouldIgnore(left)) return left;
-                let right = simplify(expression['right']);
-                if (shouldIgnore(right)) return right;
-                switch (expression['operator']) {
-                  case '&&':
-                    return left && right;
-                  case '||':
-                    return left || right;
-                  case '|':
-                    return left | right;
-                  case '^':
-                    return left ^ right;
-                  case '&':
-                    return left & right;
-                  case '==':
-                    return left == right;
-                  case '!=':
-                    return left != right;
-                  case '===':
-                    return left === right;
-                  case '!==':
-                    return left !== right;
-                  case '<':
-                    return left < right;
-                  case '>':
-                    return left > right;
-                  case '<=':
-                    return left <= right;
-                  case '>=':
-                    return left >= right;
-                  case '<<':
-                    return left << right;
-                  case '>>':
-                    return left >> right;
-                  case '+':
-                    return left + right;
-                  case '-':
-                    return left - right;
-                  case '*':
-                    return left * right;
-                  case '/':
-                    return left / right;
-                  case '%':
-                    return left % right;
-                }
-                return null;
-              case 'if':
-                let condition = simplify(expression['condition']);
-                return condition ? simplify(expression['thenExpression']) :
-                                   simplify(expression['elseExpression']);
-              case 'pre':
-                let operand = simplify(expression['operand']);
-                if (shouldIgnore(operand)) return operand;
-                switch (expression['operator']) {
-                  case '+':
-                    return operand;
-                  case '-':
-                    return -operand;
-                  case '!':
-                    return !operand;
-                  case '~':
-                    return ~operand;
-                }
-                return null;
-              case 'index':
-                let indexTarget = simplify(expression['expression']);
-                let index = simplify(expression['index']);
-                if (indexTarget && isPrimitive(index)) return indexTarget[index];
-                return null;
-              case 'select':
-                const member = expression['member'];
-                let selectContext = context;
-                let selectTarget = simplify(expression['expression']);
-                if (selectTarget instanceof StaticSymbol) {
-                  const members = selectTarget.members.concat(member);
-                  selectContext =
-                      self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
-                  const declarationValue = resolveReferenceValue(selectContext);
-                  if (declarationValue) {
-                    return simplifyInContext(selectContext, declarationValue, depth + 1);
-                  } else {
-                    return selectContext;
-                  }
-                }
-                if (selectTarget && isPrimitive(member))
-                  return simplifyInContext(selectContext, selectTarget[member], depth + 1);
-                return null;
-              case 'reference':
-                // Note: This only has to deal with variable references,
-                // as symbol references have been converted into StaticSymbols already
-                // in the StaticSymbolResolver!
-                const name: string = expression['name'];
-                const localValue = scope.resolve(name);
-                if (localValue != BindingScope.missing) {
-                  return localValue;
-                }
-                break;
-              case 'class':
-                return context;
-              case 'function':
-                return context;
-              case 'new':
-              case 'call':
-                // Determine if the function is a built-in conversion
-                staticSymbol = simplifyInContext(context, expression['expression'], depth + 1);
-                if (staticSymbol instanceof StaticSymbol) {
-                  if (staticSymbol === self.opaqueToken) {
-                    // if somebody calls new OpaqueToken, don't create an OpaqueToken,
-                    // but rather return the symbol to which the OpaqueToken is assigned to.
-                    return context;
-                  }
-                  const argExpressions: any[] = expression['arguments'] || [];
-                  let converter = self.conversionMap.get(staticSymbol);
-                  if (converter) {
-                    const args =
-                        argExpressions.map(arg => simplifyInContext(context, arg, depth + 1));
-                    return converter(context, args);
-                  } else {
-                    // Determine if the function is one we can simplify.
-                    const targetFunction = resolveReferenceValue(staticSymbol);
-                    return simplifyCall(staticSymbol, targetFunction, argExpressions);
-                  }
-                }
-                break;
-              case 'error':
-                let message = produceErrorMessage(expression);
-                if (expression['line']) {
-                  message =
-                      `${message} (position ${expression['line']+1}:${expression['character']+1} in the original .ts file)`;
-                  throw positionalError(
-                      message, context.filePath, expression['line'], expression['character']);
-                }
-                throw new Error(message);
-            }
-            return null;
-          }
-          return mapStringMap(expression, (value, name) => simplify(value));
-        }
-        return null;
-      }
-
-      try {
-        return simplify(value);
-      } catch (e) {
-        const members = context.members.length ? `.${context.members.join('.')}` : '';
-        const message =
-            `${e.message}, resolving symbol ${context.name}${members} in ${context.filePath}`;
-        if (e.fileName) {
-          throw positionalError(message, e.fileName, e.line, e.column);
-        }
-        throw new Error(message);
-      }
-    }
-
-    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;
-    }
-    return result;
-  }
-
-  private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(type);
-    return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :
-                                                       {__symbolic: 'class'};
-  }
-}
-
-function expandedMessage(error: any): string {
-  switch (error.message) {
-    case 'Reference to non-exported class':
-      if (error.context && error.context.className) {
-        return `Reference to a non-exported class ${error.context.className}. Consider exporting the class`;
-      }
-      break;
-    case 'Variable not initialized':
-      return 'Only initialized variables and constants can be referenced because the value of this variable is needed by the template compiler';
-    case 'Destructuring not supported':
-      return 'Referencing an exported destructured variable or constant is not supported by the template compiler. Consider simplifying this to avoid destructuring';
-    case 'Could not resolve type':
-      if (error.context && error.context.typeName) {
-        return `Could not resolve type ${error.context.typeName}`;
-      }
-      break;
-    case 'Function call not supported':
-      let prefix =
-          error.context && error.context.name ? `Calling function '${error.context.name}', f` : 'F';
-      return prefix +
-          'unction calls are not supported. Consider replacing the function or lambda with a reference to an exported function';
-    case 'Reference to a local symbol':
-      if (error.context && error.context.name) {
-        return `Reference to a local (non-exported) symbol '${error.context.name}'. Consider exporting the symbol`;
-      }
-      break;
-  }
-  return error.message;
-}
-
-function produceErrorMessage(error: any): string {
-  return `Error encountered resolving symbol values statically. ${expandedMessage(error)}`;
-}
-
-function mapStringMap(input: {[key: string]: any}, transform: (value: any, key: string) => any):
-    {[key: string]: any} {
-  if (!input) return {};
-  const result: {[key: string]: any} = {};
-  Object.keys(input).forEach((key) => {
-    const value = transform(input[key], key);
-    if (!shouldIgnore(value)) {
-      if (HIDDEN_KEY.test(key)) {
-        Object.defineProperty(result, key, {enumerable: false, configurable: true, value: value});
-      } else {
-        result[key] = value;
-      }
-    }
-  });
-  return result;
-}
-
-function isPrimitive(o: any): boolean {
-  return o === null || (typeof o !== 'function' && typeof o !== 'object');
-}
-
-interface BindingScopeBuilder {
-  define(name: string, value: any): BindingScopeBuilder;
-  done(): BindingScope;
-}
-
-abstract class BindingScope {
-  abstract resolve(name: string): any;
-  public static missing = {};
-  public static empty: BindingScope = {resolve: name => BindingScope.missing};
-
-  public static build(): BindingScopeBuilder {
-    const current = new Map<string, any>();
-    return {
-      define: function(name, value) {
-        current.set(name, value);
-        return this;
-      },
-      done: function() {
-        return current.size > 0 ? new PopulatedScope(current) : BindingScope.empty;
-      }
-    };
-  }
-}
-
-class PopulatedScope extends BindingScope {
-  constructor(private bindings: Map<string, any>) { super(); }
-
-  resolve(name: string): any {
-    return this.bindings.has(name) ? this.bindings.get(name) : BindingScope.missing;
-  }
-}
-
-function shouldIgnore(value: any): boolean {
-  return value && value.__symbolic == 'ignore';
-}
-
-function positionalError(message: string, fileName: string, line: number, column: number): Error {
-  const result = new Error(message);
-  (result as any).fileName = fileName;
-  (result as any).line = line;
-  (result as any).column = column;
-  return result;
-}

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

@@ -1,36 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * A token representing the a reference to a static type.
- *
- * This token is unique for a filePath and name and can be used as a hash table key.
- */
-export class StaticSymbol {
-  constructor(public filePath: string, public name: string, public members?: string[]) {}
-}
-
-/**
- * A cache of static symbol used by the StaticReflector to return the same symbol for the
- * same symbol values.
- */
-export class StaticSymbolCache {
-  private cache = new Map<string, StaticSymbol>();
-
-  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    members = members || [];
-    const memberSuffix = members.length ? `.${ members.join('.')}` : '';
-    const key = `"${declarationFile}".${name}${memberSuffix}`;
-    let result = this.cache.get(key);
-    if (!result) {
-      result = new StaticSymbol(declarationFile, name, members);
-      this.cache.set(key, result);
-    }
-    return result;
-  }
-}

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

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

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

@@ -1,77 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Summary, SummaryResolver} from '../summary_resolver';
-
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol} from './static_symbol_resolver';
-import {deserializeSummaries, summaryFileName} from './summary_serializer';
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export interface AotSummaryResolverHost {
-  /**
-   * Loads an NgModule/Directive/Pipe summary file
-   */
-  loadSummary(filePath: string): string /*|null*/;
-
-  /**
-   * Returns whether a file is a source file or not.
-   */
-  isSourceFile(sourceFilePath: string): boolean;
-}
-
-export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
-  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
-  private loadedFilePaths = new Set<string>();
-
-  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
-
-  private _assertNoMembers(symbol: StaticSymbol) {
-    if (symbol.members.length) {
-      throw new Error(
-          `Internal state: StaticSymbols in summaries can't have members! ${JSON.stringify(symbol)}`);
-    }
-  }
-
-  resolveSummary(staticSymbol: StaticSymbol): Summary<StaticSymbol> {
-    this._assertNoMembers(staticSymbol);
-    let summary = this.summaryCache.get(staticSymbol);
-    if (!summary) {
-      this._loadSummaryFile(staticSymbol.filePath);
-      summary = this.summaryCache.get(staticSymbol);
-    }
-    return summary;
-  }
-
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    this._loadSummaryFile(filePath);
-    return Array.from(this.summaryCache.keys()).filter((symbol) => symbol.filePath === filePath);
-  }
-
-  private _loadSummaryFile(filePath: string) {
-    if (this.loadedFilePaths.has(filePath)) {
-      return;
-    }
-    this.loadedFilePaths.add(filePath);
-    if (!this.host.isSourceFile(filePath)) {
-      const summaryFilePath = summaryFileName(filePath);
-      let json: string;
-      try {
-        json = this.host.loadSummary(summaryFilePath);
-      } catch (e) {
-        console.error(`Error loading summary file ${summaryFilePath}`);
-        throw e;
-      }
-      if (json) {
-        const readSummaries = deserializeSummaries(this.staticSymbolCache, json);
-        readSummaries.forEach((summary) => { this.summaryCache.set(summary.symbol, summary); });
-      }
-    }
-  }
-}

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

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

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

@@ -8,12 +8,11 @@
 
 import {ChangeDetectionStrategy, SchemaMetadata, Type, ViewEncapsulation} from '@angular/core';
 
-import {StaticSymbol} from './aot/static_symbol';
 import {ListWrapper} from './facade/collection';
-import {isPresent, stringify} from './facade/lang';
-import {LifecycleHooks, reflector} from './private_import_core';
+import {isPresent} from './facade/lang';
+import {LifecycleHooks} from './private_import_core';
 import {CssSelector} from './selector';
-import {splitAtColon} from './util';
+import {sanitizeIdentifier, splitAtColon} from './util';
 
 function unimplemented(): any {
   throw new Error('unimplemented');
@@ -25,6 +24,10 @@ function unimplemented(): any {
 // group 3: "@trigger" from "@trigger"
 const HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/;
 
+export abstract class CompileMetadataWithIdentifier {
+  get identifier(): CompileIdentifierMetadata { return <CompileIdentifierMetadata>unimplemented(); }
+}
+
 export class CompileAnimationEntryMetadata {
   constructor(
       public name: string = null, public definitions: CompileAnimationStateMetadata[] = null) {}
@@ -75,50 +78,24 @@ export class CompileAnimationGroupMetadata extends CompileAnimationWithStepsMeta
   constructor(steps: CompileAnimationMetadata[] = null) { super(steps); }
 }
 
+export class CompileIdentifierMetadata implements CompileMetadataWithIdentifier {
+  reference: any;
+  name: string;
+  prefix: string;
+  moduleUrl: string;
+  value: any;
 
-function _sanitizeIdentifier(name: string): string {
-  return name.replace(/\W/g, '_');
-}
-
-let _anonymousTypeIndex = 0;
-
-export function identifierName(compileIdentifier: CompileIdentifierMetadata): string {
-  if (!compileIdentifier || !compileIdentifier.reference) {
-    return null;
+  constructor(
+      {reference, name, moduleUrl, prefix, value}:
+          {reference?: any, name?: string, moduleUrl?: string, prefix?: string, value?: any} = {}) {
+    this.reference = reference;
+    this.name = name;
+    this.prefix = prefix;
+    this.moduleUrl = moduleUrl;
+    this.value = value;
   }
-  const ref = compileIdentifier.reference;
-  if (ref instanceof StaticSymbol) {
-    return ref.name;
-  }
-  if (ref['__anonymousType']) {
-    return ref['__anonymousType'];
-  }
-  let identifier = stringify(ref);
-  if (identifier.indexOf('(') >= 0) {
-    // case: anonymous functions!
-    identifier = `anonymous_${_anonymousTypeIndex++}`;
-    ref['__anonymousType'] = identifier;
-  } else {
-    identifier = _sanitizeIdentifier(identifier);
-  }
-  return identifier;
-}
 
-export function identifierModuleUrl(compileIdentifier: CompileIdentifierMetadata): string {
-  const ref = compileIdentifier.reference;
-  if (ref instanceof StaticSymbol) {
-    return ref.filePath;
-  }
-  return reflector.importUri(ref);
-}
-
-export interface CompileIdentifierMetadata { reference: any; }
-
-export enum CompileSummaryKind {
-  Pipe,
-  Directive,
-  NgModule,
-  Injectable
+  get identifier(): CompileIdentifierMetadata { return this; }
 }
 
 /**
@@ -126,70 +103,158 @@ export enum CompileSummaryKind {
  * in other modules / components. However, this data is not enough to compile
  * the directive / module itself.
  */
-export interface CompileTypeSummary {
-  summaryKind: CompileSummaryKind;
-  type: CompileTypeMetadata;
+export interface CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
 }
 
-export interface CompileDiDependencyMetadata {
-  isAttribute?: boolean;
-  isSelf?: boolean;
-  isHost?: boolean;
-  isSkipSelf?: boolean;
-  isOptional?: boolean;
-  isValue?: boolean;
-  token?: CompileTokenMetadata;
-  value?: any;
-}
-
-export interface CompileProviderMetadata {
+export class CompileDiDependencyMetadata {
+  isAttribute: boolean;
+  isSelf: boolean;
+  isHost: boolean;
+  isSkipSelf: boolean;
+  isOptional: boolean;
+  isValue: boolean;
   token: CompileTokenMetadata;
-  useClass?: CompileTypeMetadata;
-  useValue?: any;
-  useExisting?: CompileTokenMetadata;
-  useFactory?: CompileFactoryMetadata;
-  deps?: CompileDiDependencyMetadata[];
-  multi?: boolean;
-}
+  value: any;
 
-export interface CompileFactoryMetadata extends CompileIdentifierMetadata {
-  diDeps: CompileDiDependencyMetadata[];
-  reference: any;
-}
-
-export function tokenName(token: CompileTokenMetadata) {
-  return isPresent(token.value) ? _sanitizeIdentifier(token.value) :
-                                  identifierName(token.identifier);
-}
-
-export function tokenReference(token: CompileTokenMetadata) {
-  if (isPresent(token.identifier)) {
-    return token.identifier.reference;
-  } else {
-    return token.value;
+  constructor({isAttribute, isSelf, isHost, isSkipSelf, isOptional, isValue, token, value}: {
+    isAttribute?: boolean,
+    isSelf?: boolean,
+    isHost?: boolean,
+    isSkipSelf?: boolean,
+    isOptional?: boolean,
+    isValue?: boolean,
+    query?: CompileQueryMetadata,
+    viewQuery?: CompileQueryMetadata,
+    token?: CompileTokenMetadata,
+    value?: any
+  } = {}) {
+    this.isAttribute = !!isAttribute;
+    this.isSelf = !!isSelf;
+    this.isHost = !!isHost;
+    this.isSkipSelf = !!isSkipSelf;
+    this.isOptional = !!isOptional;
+    this.isValue = !!isValue;
+    this.token = token;
+    this.value = value;
   }
 }
 
-export interface CompileTokenMetadata {
-  value?: any;
-  identifier?: CompileIdentifierMetadata|CompileTypeMetadata;
+export class CompileProviderMetadata {
+  token: CompileTokenMetadata;
+  useClass: CompileTypeMetadata;
+  useValue: any;
+  useExisting: CompileTokenMetadata;
+  useFactory: CompileFactoryMetadata;
+  deps: CompileDiDependencyMetadata[];
+  multi: boolean;
+
+  constructor({token, useClass, useValue, useExisting, useFactory, deps, multi}: {
+    token?: CompileTokenMetadata,
+    useClass?: CompileTypeMetadata,
+    useValue?: any,
+    useExisting?: CompileTokenMetadata,
+    useFactory?: CompileFactoryMetadata,
+    deps?: CompileDiDependencyMetadata[],
+    multi?: boolean
+  }) {
+    this.token = token;
+    this.useClass = useClass;
+    this.useValue = useValue;
+    this.useExisting = useExisting;
+    this.useFactory = useFactory;
+    this.deps = deps || null;
+    this.multi = !!multi;
+  }
+}
+
+export class CompileFactoryMetadata extends CompileIdentifierMetadata {
+  diDeps: CompileDiDependencyMetadata[];
+
+  constructor({reference, name, moduleUrl, prefix, diDeps, value}: {
+    reference?: Function,
+    name?: string,
+    prefix?: string,
+    moduleUrl?: string,
+    value?: boolean,
+    diDeps?: CompileDiDependencyMetadata[]
+  }) {
+    super({reference: reference, name: name, prefix: prefix, moduleUrl: moduleUrl, value: value});
+    this.diDeps = _normalizeArray(diDeps);
+  }
+}
+
+export class CompileTokenMetadata implements CompileMetadataWithIdentifier {
+  value: any;
+  identifier: CompileIdentifierMetadata;
+  identifierIsInstance: boolean;
+
+  constructor(
+      {value, identifier, identifierIsInstance}:
+          {value?: any, identifier?: CompileIdentifierMetadata, identifierIsInstance?: boolean}) {
+    this.value = value;
+    this.identifier = identifier;
+    this.identifierIsInstance = !!identifierIsInstance;
+  }
+
+  get reference(): any {
+    if (isPresent(this.identifier)) {
+      return this.identifier.reference;
+    } else {
+      return this.value;
+    }
+  }
+
+  get name(): string {
+    return isPresent(this.value) ? sanitizeIdentifier(this.value) : this.identifier.name;
+  }
 }
 
 /**
  * Metadata regarding compilation of a type.
  */
-export interface CompileTypeMetadata extends CompileIdentifierMetadata {
+export class CompileTypeMetadata extends CompileIdentifierMetadata {
+  isHost: boolean;
   diDeps: CompileDiDependencyMetadata[];
   lifecycleHooks: LifecycleHooks[];
-  reference: any;
+
+  constructor({reference, name, moduleUrl, prefix, isHost, value, diDeps, lifecycleHooks}: {
+    reference?: Type<any>,
+    name?: string,
+    moduleUrl?: string,
+    prefix?: string,
+    isHost?: boolean,
+    value?: any,
+    diDeps?: CompileDiDependencyMetadata[],
+    lifecycleHooks?: LifecycleHooks[];
+  } = {}) {
+    super({reference: reference, name: name, moduleUrl: moduleUrl, prefix: prefix, value: value});
+    this.isHost = !!isHost;
+    this.diDeps = _normalizeArray(diDeps);
+    this.lifecycleHooks = _normalizeArray(lifecycleHooks);
+  }
 }
 
-export interface CompileQueryMetadata {
+export class CompileQueryMetadata {
   selectors: Array<CompileTokenMetadata>;
   descendants: boolean;
   first: boolean;
   propertyName: string;
   read: CompileTokenMetadata;
+
+  constructor({selectors, descendants, first, propertyName, read}: {
+    selectors?: Array<CompileTokenMetadata>,
+    descendants?: boolean,
+    first?: boolean,
+    propertyName?: string,
+    read?: CompileTokenMetadata
+  } = {}) {
+    this.selectors = selectors;
+    this.descendants = !!descendants;
+    this.first = !!first;
+    this.propertyName = propertyName;
+    this.read = read;
+  }
 }
 
 /**
@@ -211,7 +276,8 @@ export class CompileStylesheetMetadata {
 /**
  * Summary Metadata regarding compilation of a template.
  */
-export interface CompileTemplateSummary {
+export interface CompileTemplateSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
   animations: string[];
   ngContentSelectors: string[];
   encapsulation: ViewEncapsulation;
@@ -259,6 +325,7 @@ export class CompileTemplateMetadata {
 
   toSummary(): CompileTemplateSummary {
     return {
+      isSummary: true,
       animations: this.animations.map(anim => anim.name),
       ngContentSelectors: this.ngContentSelectors,
       encapsulation: this.encapsulation
@@ -266,9 +333,8 @@ export class CompileTemplateMetadata {
   }
 }
 
-// Note: This should only use interfaces as nested data types
-// as we need to be able to serialize this from/to JSON!
-export interface CompileDirectiveSummary extends CompileTypeSummary {
+export interface CompileDirectiveSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
   type: CompileTypeMetadata;
   isComponent: boolean;
   selector: string;
@@ -289,11 +355,10 @@ export interface CompileDirectiveSummary extends CompileTypeSummary {
 /**
  * Metadata regarding compilation of a directive.
  */
-export class CompileDirectiveMetadata {
+export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
   static create(
-      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host,
-       providers, viewProviders, queries, viewQueries, entryComponents, template}: {
-        isHost?: boolean,
+      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host, providers,
+       viewProviders, queries, viewQueries, entryComponents, template}: {
         type?: CompileTypeMetadata,
         isComponent?: boolean,
         selector?: string,
@@ -302,8 +367,10 @@ export class CompileDirectiveMetadata {
         inputs?: string[],
         outputs?: string[],
         host?: {[key: string]: string},
-        providers?: CompileProviderMetadata[],
-        viewProviders?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        viewProviders?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
         queries?: CompileQueryMetadata[],
         viewQueries?: CompileQueryMetadata[],
         entryComponents?: CompileIdentifierMetadata[],
@@ -345,7 +412,6 @@ export class CompileDirectiveMetadata {
     }
 
     return new CompileDirectiveMetadata({
-      isHost,
       type,
       isComponent: !!isComponent, selector, exportAs, changeDetection,
       inputs: inputsMap,
@@ -361,7 +427,6 @@ export class CompileDirectiveMetadata {
       template,
     });
   }
-  isHost: boolean;
   type: CompileTypeMetadata;
   isComponent: boolean;
   selector: string;
@@ -381,10 +446,9 @@ export class CompileDirectiveMetadata {
   template: CompileTemplateMetadata;
 
   constructor(
-      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
-       hostListeners, hostProperties, hostAttributes, providers, viewProviders, queries,
-       viewQueries, entryComponents, template}: {
-        isHost?: boolean,
+      {type, isComponent, selector, exportAs, changeDetection, inputs, outputs, hostListeners,
+       hostProperties, hostAttributes, providers, viewProviders, queries, viewQueries,
+       entryComponents, template}: {
         type?: CompileTypeMetadata,
         isComponent?: boolean,
         selector?: string,
@@ -395,14 +459,15 @@ export class CompileDirectiveMetadata {
         hostListeners?: {[key: string]: string},
         hostProperties?: {[key: string]: string},
         hostAttributes?: {[key: string]: string},
-        providers?: CompileProviderMetadata[],
-        viewProviders?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
+        viewProviders?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
         queries?: CompileQueryMetadata[],
         viewQueries?: CompileQueryMetadata[],
         entryComponents?: CompileIdentifierMetadata[],
         template?: CompileTemplateMetadata,
       } = {}) {
-    this.isHost = !!isHost;
     this.type = type;
     this.isComponent = isComponent;
     this.selector = selector;
@@ -422,9 +487,11 @@ export class CompileDirectiveMetadata {
     this.template = template;
   }
 
+  get identifier(): CompileIdentifierMetadata { return this.type; }
+
   toSummary(): CompileDirectiveSummary {
     return {
-      summaryKind: CompileSummaryKind.Directive,
+      isSummary: true,
       type: this.type,
       isComponent: this.isComponent,
       selector: this.selector,
@@ -447,12 +514,16 @@ export class CompileDirectiveMetadata {
 /**
  * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
  */
-export function createHostComponentMeta(
-    typeReference: any, compMeta: CompileDirectiveMetadata): CompileDirectiveMetadata {
+export function createHostComponentMeta(compMeta: CompileDirectiveMetadata):
+    CompileDirectiveMetadata {
   const template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate();
   return CompileDirectiveMetadata.create({
-    isHost: true,
-    type: {reference: typeReference, diDeps: [], lifecycleHooks: []},
+    type: new CompileTypeMetadata({
+      reference: Object,
+      name: `${compMeta.type.name}_Host`,
+      moduleUrl: compMeta.type.moduleUrl,
+      isHost: true
+    }),
     template: new CompileTemplateMetadata({
       encapsulation: ViewEncapsulation.None,
       template: template,
@@ -475,13 +546,14 @@ export function createHostComponentMeta(
   });
 }
 
-export interface CompilePipeSummary extends CompileTypeSummary {
+export interface CompilePipeSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
   type: CompileTypeMetadata;
   name: string;
   pure: boolean;
 }
 
-export class CompilePipeMetadata {
+export class CompilePipeMetadata implements CompileMetadataWithIdentifier {
   type: CompileTypeMetadata;
   name: string;
   pure: boolean;
@@ -495,44 +567,42 @@ export class CompilePipeMetadata {
     this.name = name;
     this.pure = !!pure;
   }
+  get identifier(): CompileIdentifierMetadata { return this.type; }
 
   toSummary(): CompilePipeSummary {
-    return {
-      summaryKind: CompileSummaryKind.Pipe,
-      type: this.type,
-      name: this.name,
-      pure: this.pure
-    };
+    return {isSummary: true, type: this.type, name: this.name, pure: this.pure};
   }
 }
 
-// Note: This should only use interfaces as nested data types
-// as we need to be able to serialize this from/to JSON!
-export interface CompileNgModuleSummary extends CompileTypeSummary {
+export interface CompileNgModuleInjectorSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
   type: CompileTypeMetadata;
-
-  // Note: This is transitive over the exported modules.
-  exportedDirectives: CompileIdentifierMetadata[];
-  // Note: This is transitive over the exported modules.
-  exportedPipes: CompileIdentifierMetadata[];
-
-  // Note: This is transitive.
   entryComponents: CompileIdentifierMetadata[];
-  // Note: This is transitive.
-  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[];
-  // Note: This is transitive.
-  modules: CompileTypeMetadata[];
+  providers: CompileProviderMetadata[];
+  importedModules: CompileNgModuleInjectorSummary[];
+  exportedModules: CompileNgModuleInjectorSummary[];
 }
 
+export interface CompileNgModuleDirectiveSummary extends CompileSummary {
+  isSummary: boolean /* TODO: `true` when we drop TS 1.8 support */;
+  type: CompileTypeMetadata;
+  exportedDirectives: CompileIdentifierMetadata[];
+  exportedPipes: CompileIdentifierMetadata[];
+  exportedModules: CompileNgModuleDirectiveSummary[];
+  directiveLoaders: (() => Promise<void>)[];
+}
+
+export type CompileNgModuleSummary =
+    CompileNgModuleInjectorSummary & CompileNgModuleDirectiveSummary;
+
 /**
  * Metadata regarding compilation of a module.
  */
-export class CompileNgModuleMetadata {
+export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
   type: CompileTypeMetadata;
   declaredDirectives: CompileIdentifierMetadata[];
   exportedDirectives: CompileIdentifierMetadata[];
   declaredPipes: CompileIdentifierMetadata[];
-
   exportedPipes: CompileIdentifierMetadata[];
   entryComponents: CompileIdentifierMetadata[];
   bootstrapComponents: CompileIdentifierMetadata[];
@@ -550,7 +620,8 @@ export class CompileNgModuleMetadata {
        entryComponents, bootstrapComponents, importedModules, exportedModules, schemas,
        transitiveModule, id}: {
         type?: CompileTypeMetadata,
-        providers?: CompileProviderMetadata[],
+        providers?:
+            Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>,
         declaredDirectives?: CompileIdentifierMetadata[],
         exportedDirectives?: CompileIdentifierMetadata[],
         declaredPipes?: CompileIdentifierMetadata[],
@@ -578,81 +649,84 @@ export class CompileNgModuleMetadata {
     this.transitiveModule = transitiveModule;
   }
 
+  get identifier(): CompileIdentifierMetadata { return this.type; }
+
   toSummary(): CompileNgModuleSummary {
     return {
-      summaryKind: CompileSummaryKind.NgModule,
+      isSummary: true,
       type: this.type,
-      entryComponents: this.transitiveModule.entryComponents,
-      providers: this.transitiveModule.providers,
-      modules: this.transitiveModule.modules,
-      exportedDirectives: this.transitiveModule.exportedDirectives,
-      exportedPipes: this.transitiveModule.exportedPipes
+      entryComponents: this.entryComponents,
+      providers: this.providers,
+      importedModules: this.importedModules,
+      exportedModules: this.exportedModules,
+      exportedDirectives: this.exportedDirectives,
+      exportedPipes: this.exportedPipes,
+      directiveLoaders: this.transitiveModule.directiveLoaders
+    };
+  }
+
+  toInjectorSummary(): CompileNgModuleInjectorSummary {
+    return {
+      isSummary: true,
+      type: this.type,
+      entryComponents: this.entryComponents,
+      providers: this.providers,
+      importedModules: this.importedModules,
+      exportedModules: this.exportedModules
+    };
+  }
+  toDirectiveSummary(): CompileNgModuleDirectiveSummary {
+    return {
+      isSummary: true,
+      type: this.type,
+      exportedDirectives: this.exportedDirectives,
+      exportedPipes: this.exportedPipes,
+      exportedModules: this.exportedModules,
+      directiveLoaders: this.transitiveModule.directiveLoaders
     };
   }
 }
 
 export class TransitiveCompileNgModuleMetadata {
   directivesSet = new Set<any>();
-  directives: CompileIdentifierMetadata[] = [];
-  exportedDirectivesSet = new Set<any>();
-  exportedDirectives: CompileIdentifierMetadata[] = [];
   pipesSet = new Set<any>();
-  pipes: CompileIdentifierMetadata[] = [];
-  exportedPipesSet = new Set<any>();
-  exportedPipes: CompileIdentifierMetadata[] = [];
-  modulesSet = new Set<any>();
-  modules: CompileTypeMetadata[] = [];
-  entryComponentsSet = new Set<any>();
-  entryComponents: CompileIdentifierMetadata[] = [];
 
-  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[] = [];
+  constructor(
+      public modules: CompileNgModuleInjectorSummary[], public providers: CompileProviderMetadata[],
+      public entryComponents: CompileIdentifierMetadata[],
+      public directives: CompileIdentifierMetadata[], public pipes: CompileIdentifierMetadata[],
+      public directiveLoaders: (() => Promise<void>)[]) {
+    directives.forEach(dir => this.directivesSet.add(dir.reference));
+    pipes.forEach(pipe => this.pipesSet.add(pipe.reference));
+  }
+}
 
-  addProvider(provider: CompileProviderMetadata, module: CompileIdentifierMetadata) {
-    this.providers.push({provider: provider, module: module});
-  }
+export function removeIdentifierDuplicates<T extends CompileMetadataWithIdentifier>(items: T[]):
+    T[] {
+  const map = new Map<any, T>();
 
-  addDirective(id: CompileIdentifierMetadata) {
-    if (!this.directivesSet.has(id.reference)) {
-      this.directivesSet.add(id.reference);
-      this.directives.push(id);
+  items.forEach((item) => {
+    if (!map.get(item.identifier.reference)) {
+      map.set(item.identifier.reference, item);
     }
-  }
-  addExportedDirective(id: CompileIdentifierMetadata) {
-    if (!this.exportedDirectivesSet.has(id.reference)) {
-      this.exportedDirectivesSet.add(id.reference);
-      this.exportedDirectives.push(id);
-    }
-  }
-  addPipe(id: CompileIdentifierMetadata) {
-    if (!this.pipesSet.has(id.reference)) {
-      this.pipesSet.add(id.reference);
-      this.pipes.push(id);
-    }
-  }
-  addExportedPipe(id: CompileIdentifierMetadata) {
-    if (!this.exportedPipesSet.has(id.reference)) {
-      this.exportedPipesSet.add(id.reference);
-      this.exportedPipes.push(id);
-    }
-  }
-  addModule(id: CompileTypeMetadata) {
-    if (!this.modulesSet.has(id.reference)) {
-      this.modulesSet.add(id.reference);
-      this.modules.push(id);
-    }
-  }
-  addEntryComponent(id: CompileIdentifierMetadata) {
-    if (!this.entryComponentsSet.has(id.reference)) {
-      this.entryComponentsSet.add(id.reference);
-      this.entryComponents.push(id);
-    }
-  }
+  });
+
+  return Array.from(map.values());
 }
 
 function _normalizeArray(obj: any[]): any[] {
   return obj || [];
 }
 
+export function isStaticSymbol(value: any): value is StaticSymbol {
+  return typeof value === 'object' && value !== null && value['name'] && value['filePath'];
+}
+
+export interface StaticSymbol {
+  name: string;
+  filePath: string;
+}
+
 export class ProviderMeta {
   token: any;
   useClass: Type<any>;

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

@@ -6,33 +6,30 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
+import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Injectable, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
 
-import {AnimationParser} from '../animation/animation_parser';
-import {CompilerConfig} from '../config';
-import {DirectiveNormalizer} from '../directive_normalizer';
-import {DirectiveResolver} from '../directive_resolver';
-import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
-import {Lexer} from '../expression_parser/lexer';
-import {Parser} from '../expression_parser/parser';
-import * as i18n from '../i18n/index';
-import {CompilerInjectable} from '../injectable';
-import {CompileMetadataResolver} from '../metadata_resolver';
-import {HtmlParser} from '../ml_parser/html_parser';
-import {NgModuleCompiler} from '../ng_module_compiler';
-import {NgModuleResolver} from '../ng_module_resolver';
-import {PipeResolver} from '../pipe_resolver';
-import {Console, ReflectionCapabilities, Reflector, ReflectorReader, reflector} from '../private_import_core';
-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';
-
-import {JitCompiler} from './compiler';
+import {AnimationParser} from './animation/animation_parser';
+import {CompilerConfig} from './config';
+import {DirectiveNormalizer} from './directive_normalizer';
+import {DirectiveResolver} from './directive_resolver';
+import {DirectiveWrapperCompiler} from './directive_wrapper_compiler';
+import {Lexer} from './expression_parser/lexer';
+import {Parser} from './expression_parser/parser';
+import * as i18n from './i18n/index';
+import {CompileMetadataResolver} from './metadata_resolver';
+import {HtmlParser} from './ml_parser/html_parser';
+import {NgModuleCompiler} from './ng_module_compiler';
+import {NgModuleResolver} from './ng_module_resolver';
+import {PipeResolver} from './pipe_resolver';
+import {Console, ReflectionCapabilities, Reflector, ReflectorReader, reflector} from './private_import_core';
+import {ResourceLoader} from './resource_loader';
+import {RuntimeCompiler} from './runtime_compiler';
+import {DomElementSchemaRegistry} from './schema/dom_element_schema_registry';
+import {ElementSchemaRegistry} from './schema/element_schema_registry';
+import {StyleCompiler} from './style_compiler';
+import {TemplateParser} from './template_parser/template_parser';
+import {DEFAULT_PACKAGE_URL_PROVIDER, UrlResolver} from './url_resolver';
+import {ViewCompiler} from './view_compiler/view_compiler';
 
 const _NO_RESOURCE_LOADER: ResourceLoader = {
   get(url: string): Promise<string>{
@@ -41,14 +38,13 @@ const _NO_RESOURCE_LOADER: ResourceLoader = {
 };
 
 /**
- * A set of providers that provide `JitCompiler` and its dependencies to use for
+ * A set of providers that provide `RuntimeCompiler` and its dependencies to use for
  * template compilation.
  */
 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,
@@ -72,8 +68,8 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
   NgModuleCompiler,
   DirectiveWrapperCompiler,
   {provide: CompilerConfig, useValue: new CompilerConfig()},
-  JitCompiler,
-  {provide: Compiler, useExisting: JitCompiler},
+  RuntimeCompiler,
+  {provide: Compiler, useExisting: RuntimeCompiler},
   DomElementSchemaRegistry,
   {provide: ElementSchemaRegistry, useExisting: DomElementSchemaRegistry},
   UrlResolver,
@@ -84,8 +80,8 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
 ];
 
 
-@CompilerInjectable()
-export class JitCompilerFactory implements CompilerFactory {
+@Injectable()
+export class RuntimeCompilerFactory implements CompilerFactory {
   private _defaultOptions: CompilerOptions[];
   constructor(@Inject(COMPILER_OPTIONS) defaultOptions: CompilerOptions[]) {
     this._defaultOptions = [<CompilerOptions>{
@@ -132,7 +128,7 @@ function _initReflector() {
  */
 export const platformCoreDynamic = createPlatformFactory(platformCore, 'coreDynamic', [
   {provide: COMPILER_OPTIONS, useValue: {}, multi: true},
-  {provide: CompilerFactory, useClass: JitCompilerFactory},
+  {provide: CompilerFactory, useClass: RuntimeCompilerFactory},
   {provide: PLATFORM_INITIALIZER, useValue: _initReflector, multi: true},
 ]);
 

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

@@ -5,7 +5,8 @@
  * 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 {Identifiers, createIdentifier} from '../identifiers';
+
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';
 
@@ -21,7 +22,7 @@ export function createCheckBindingField(builder: ClassBuilder): CheckBindingFiel
   // private is fine here as no child view will reference the cached value...
   builder.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
   builder.ctorStmts.push(o.THIS_EXPR.prop(fieldExpr.name)
-                             .set(o.importExpr(createIdentifier(Identifiers.UNINITIALIZED)))
+                             .set(o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED)))
                              .toStmt());
   return new CheckBindingField(fieldExpr, bindingId);
 }
@@ -29,7 +30,7 @@ export function createCheckBindingField(builder: ClassBuilder): CheckBindingFiel
 export function createCheckBindingStmt(
     evalResult: ConvertPropertyBindingResult, fieldExpr: o.ReadPropExpr,
     throwOnChangeVar: o.Expression, actions: o.Statement[]): o.Statement[] {
-  let condition: o.Expression = o.importExpr(createIdentifier(Identifiers.checkBinding)).callFn([
+  let condition: o.Expression = o.importExpr(resolveIdentifier(Identifiers.checkBinding)).callFn([
     throwOnChangeVar, fieldExpr, evalResult.currValExpr
   ]);
   if (evalResult.forceUpdate) {

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

@@ -8,8 +8,8 @@
 
 
 import * as cdAst from '../expression_parser/ast';
-import {isBlank} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
+import {isBlank, isPresent} from '../facade/lang';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';
 
@@ -116,7 +116,7 @@ export function createSharedBindingVariablesIfNeeded(stmts: o.Statement[]): o.St
   if (readVars.has(VAL_UNWRAPPER_VAR.name)) {
     unwrapperStmts.push(
         VAL_UNWRAPPER_VAR
-            .set(o.importExpr(createIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
+            .set(o.importExpr(resolveIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
             .toDeclStmt(null, [o.StmtModifier.Final]));
   }
   return unwrapperStmts;
@@ -277,20 +277,15 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     args.push(o.literal(ast.strings[ast.strings.length - 1]));
 
     return ast.expressions.length <= 9 ?
-        o.importExpr(createIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
-        o.importExpr(createIdentifier(Identifiers.interpolate)).callFn([
+        o.importExpr(resolveIdentifier(Identifiers.inlineInterpolate)).callFn(args) :
+        o.importExpr(resolveIdentifier(Identifiers.interpolate)).callFn([
           args[0], o.literalArr(args.slice(1))
         ]);
   }
 
   visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {
-    const leftMostSafe = this.leftMostSafeNode(ast);
-    if (leftMostSafe) {
-      return this.convertSafeAccess(ast, leftMostSafe, mode);
-    } else {
-      return convertToStatementIfNeeded(
-          mode, this.visit(ast.obj, _Mode.Expression).key(this.visit(ast.key, _Mode.Expression)));
-    }
+    return convertToStatementIfNeeded(
+        mode, this.visit(ast.obj, _Mode.Expression).key(this.visit(ast.key, _Mode.Expression)));
   }
 
   visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {
@@ -338,7 +333,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
       const receiver = this.visit(ast.receiver, _Mode.Expression);
       if (receiver === this._implicitReceiver) {
         const varExpr = this._getLocal(ast.name);
-        if (varExpr) {
+        if (isPresent(varExpr)) {
           result = varExpr.callFn(args);
         }
       }
@@ -374,7 +369,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     const receiver: o.Expression = this.visit(ast.receiver, _Mode.Expression);
     if (receiver === this._implicitReceiver) {
       const varExpr = this._getLocal(ast.name);
-      if (varExpr) {
+      if (isPresent(varExpr)) {
         throw new Error('Cannot assign to a reference or variable!');
       }
     }
@@ -583,7 +578,7 @@ function flattenStatements(arg: any, output: o.Statement[]) {
 
 function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[]): o.Expression {
   if (values.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_ARRAY));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_ARRAY));
   }
   const proxyExpr = o.THIS_EXPR.prop(`_arr_${builder.fields.length}`);
   const proxyParams: o.FnParam[] = [];
@@ -604,7 +599,7 @@ function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[])
 function createCachedLiteralMap(
     builder: ClassBuilder, entries: [string, o.Expression][]): o.Expression {
   if (entries.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_MAP));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_MAP));
   }
   const proxyExpr = o.THIS_EXPR.prop(`_map_${builder.fields.length}`);
   const proxyParams: o.FnParam[] = [];

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

@@ -8,12 +8,15 @@
 
 import {CompileTokenMetadata} from '../compile_metadata';
 import {isPresent} from '../facade/lang';
-import {IdentifierSpec, Identifiers, createEnumIdentifier, createIdentifier} from '../identifiers';
+import {IdentifierSpec, Identifiers, resolveEnumIdentifier, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 
 export function createDiTokenExpression(token: CompileTokenMetadata): o.Expression {
   if (isPresent(token.value)) {
     return o.literal(token.value);
+  } else if (token.identifierIsInstance) {
+    return o.importExpr(token.identifier)
+        .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
   } else {
     return o.importExpr(token.identifier);
   }
@@ -21,13 +24,13 @@ export function createDiTokenExpression(token: CompileTokenMetadata): o.Expressi
 
 export function createInlineArray(values: o.Expression[]): o.Expression {
   if (values.length === 0) {
-    return o.importExpr(createIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
   }
   const log2 = Math.log(values.length) / Math.log(2);
   const index = Math.ceil(log2);
   const identifierSpec = index < Identifiers.inlineArrays.length ? Identifiers.inlineArrays[index] :
                                                                    Identifiers.InlineArrayDynamic;
-  const identifier = createIdentifier(identifierSpec);
+  const identifier = resolveIdentifier(identifierSpec);
   return o.importExpr(identifier).instantiate([
     <o.Expression>o.literal(values.length)
   ].concat(values));
@@ -43,7 +46,7 @@ export function createPureProxy(
     throw new Error(`Unsupported number of argument for pure functions: ${argCount}`);
   }
   builder.ctorStmts.push(o.THIS_EXPR.prop(pureProxyProp.name)
-                             .set(o.importExpr(createIdentifier(pureProxyId)).callFn([fn]))
+                             .set(o.importExpr(resolveIdentifier(pureProxyId)).callFn([fn]))
                              .toStmt());
 }
 
@@ -53,5 +56,5 @@ export function createEnumExpression(enumType: IdentifierSpec, enumValue: any):
   if (!enumName) {
     throw new Error(`Unknown enum value ${enumValue} in ${enumType.name}`);
   }
-  return o.importExpr(createEnumIdentifier(enumType, enumName));
+  return o.importExpr(resolveEnumIdentifier(resolveIdentifier(enumType), enumName));
 }

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, createIdentifier} from '../identifiers';
+import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {EMPTY_STATE as EMPTY_ANIMATION_STATE} from '../private_import_core';
 import {BoundElementPropertyAst, BoundEventAst, PropertyBindingType} from '../template_parser/template_ast';
@@ -26,7 +26,7 @@ export function writeToRenderer(
     case PropertyBindingType.Property:
       if (logBindingUpdate) {
         updateStmts.push(
-            o.importExpr(createIdentifier(Identifiers.setBindingDebugInfo))
+            o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfo))
                 .callFn([renderer, renderElement, o.literal(boundProp.name), renderValue])
                 .toStmt());
       }
@@ -91,8 +91,8 @@ function sanitizedValue(
 
 export function triggerAnimation(
     view: o.Expression, componentView: o.Expression, boundProp: BoundElementPropertyAst,
-    boundOutputs: BoundEventAst[], eventListener: o.Expression, renderElement: o.Expression,
-    renderValue: o.Expression, lastRenderValue: o.Expression) {
+    eventListener: o.Expression, renderElement: o.Expression, renderValue: o.Expression,
+    lastRenderValue: o.Expression) {
   const detachStmts: o.Statement[] = [];
   const updateStmts: o.Statement[] = [];
 
@@ -104,7 +104,7 @@ export function triggerAnimation(
   // it's important to normalize the void value as `void` explicitly
   // so that the styles data can be obtained from the stringmap
   const emptyStateValue = o.literal(EMPTY_ANIMATION_STATE);
-  const unitializedValue = o.importExpr(createIdentifier(Identifiers.UNINITIALIZED));
+  const unitializedValue = o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED));
   const animationTransitionVar = o.variable('animationTransition_' + animationName);
 
   updateStmts.push(
@@ -121,32 +121,23 @@ export function triggerAnimation(
           .set(animationFnExpr.callFn([view, renderElement, lastRenderValue, emptyStateValue]))
           .toDeclStmt());
 
-  const registerStmts: o.Statement[] = [];
-  const animationStartMethodExists = boundOutputs.find(
-      event => event.isAnimation && event.name == animationName && event.phase == 'start');
-  if (animationStartMethodExists) {
-    registerStmts.push(
-        animationTransitionVar
-            .callMethod(
-                'onStart',
-                [eventListener.callMethod(
-                    o.BuiltinMethod.Bind,
-                    [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'start'))])])
-            .toStmt());
-  }
+  const registerStmts = [
+    animationTransitionVar
+        .callMethod(
+            'onStart',
+            [eventListener.callMethod(
+                o.BuiltinMethod.Bind,
+                [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'start'))])])
+        .toStmt(),
+    animationTransitionVar
+        .callMethod(
+            'onDone',
+            [eventListener.callMethod(
+                o.BuiltinMethod.Bind,
+                [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'done'))])])
+        .toStmt(),
 
-  const animationDoneMethodExists = boundOutputs.find(
-      event => event.isAnimation && event.name == animationName && event.phase == 'done');
-  if (animationDoneMethodExists) {
-    registerStmts.push(
-        animationTransitionVar
-            .callMethod(
-                'onDone',
-                [eventListener.callMethod(
-                    o.BuiltinMethod.Bind,
-                    [view, o.literal(BoundEventAst.calcFullName(animationName, null, 'done'))])])
-            .toStmt());
-  }
+  ];
 
   updateStmts.push(...registerStmts);
   detachStmts.push(...registerStmts);

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

@@ -9,7 +9,7 @@
 import {ViewEncapsulation, isDevMode} from '@angular/core';
 
 import {CompileIdentifierMetadata} from './compile_metadata';
-import {Identifiers, createIdentifier} from './identifiers';
+import {Identifiers, resolveIdentifier} from './identifiers';
 
 function unimplemented(): any {
   throw new Error('unimplemented');
@@ -61,7 +61,7 @@ export abstract class RenderTypes {
 }
 
 export class DefaultRenderTypes implements RenderTypes {
-  get renderer() { return createIdentifier(Identifiers.Renderer); };
+  get renderer() { return resolveIdentifier(Identifiers.Renderer); };
   renderText: any = null;
   renderElement: any = null;
   renderComment: any = null;

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

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

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

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, Directive, HostBinding, HostListener, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
+import {Component, Directive, HostBinding, HostListener, Injectable, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
 
-import {ListWrapper, StringMapWrapper} from './facade/collection';
+import {StringMapWrapper} from './facade/collection';
 import {stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 import {splitAtColon} from './util';
 
@@ -21,7 +20,7 @@ import {splitAtColon} from './util';
  *
  * See {@link Compiler}
  */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 
@@ -36,7 +35,7 @@ export class DirectiveResolver {
   resolve(type: Type<any>, throwIfNotFound = true): Directive {
     const typeMetadata = this._reflector.annotations(resolveForwardRef(type));
     if (typeMetadata) {
-      const metadata = ListWrapper.findLast(typeMetadata, isDirectiveMetadata);
+      const metadata = typeMetadata.find(isDirectiveMetadata);
       if (metadata) {
         const propertyMetadata = this._reflector.propMetadata(type);
         return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
@@ -59,74 +58,85 @@ export class DirectiveResolver {
     const queries: {[key: string]: any} = {};
 
     Object.keys(propertyMetadata).forEach((propName: string) => {
-      const input = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Input);
-      if (input) {
-        if (input.bindingPropertyName) {
-          inputs.push(`${propName}: ${input.bindingPropertyName}`);
-        } else {
-          inputs.push(propName);
-        }
-      }
-      const output = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Output);
-      if (output) {
-        if (output.bindingPropertyName) {
-          outputs.push(`${propName}: ${output.bindingPropertyName}`);
-        } else {
-          outputs.push(propName);
-        }
-      }
-      const hostBindings = propertyMetadata[propName].filter(a => a && a instanceof HostBinding);
-      hostBindings.forEach(hostBinding => {
-        if (hostBinding.hostPropertyName) {
-          const startWith = hostBinding.hostPropertyName[0];
-          if (startWith === '(') {
-            throw new Error(`@HostBinding can not bind to events. Use @HostListener instead.`);
-          } else if (startWith === '[') {
-            throw new Error(
-                `@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.`);
+
+      propertyMetadata[propName].forEach(a => {
+        if (a instanceof Input) {
+          if (a.bindingPropertyName) {
+            inputs.push(`${propName}: ${a.bindingPropertyName}`);
+          } else {
+            inputs.push(propName);
           }
-          host[`[${hostBinding.hostPropertyName}]`] = propName;
-        } else {
-          host[`[${propName}]`] = propName;
+        } else if (a instanceof Output) {
+          const output: Output = a;
+          if (output.bindingPropertyName) {
+            outputs.push(`${propName}: ${output.bindingPropertyName}`);
+          } else {
+            outputs.push(propName);
+          }
+        } else if (a instanceof HostBinding) {
+          const hostBinding: HostBinding = a;
+          if (hostBinding.hostPropertyName) {
+            const startWith = hostBinding.hostPropertyName[0];
+            if (startWith === '(') {
+              throw new Error(`@HostBinding can not bind to events. Use @HostListener instead.`);
+            } else if (startWith === '[') {
+              throw new Error(
+                  `@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.`);
+            }
+            host[`[${hostBinding.hostPropertyName}]`] = propName;
+          } else {
+            host[`[${propName}]`] = propName;
+          }
+        } else if (a instanceof HostListener) {
+          const hostListener: HostListener = a;
+          const args = hostListener.args || [];
+          host[`(${hostListener.eventName})`] = `${propName}(${args.join(',')})`;
+        } else if (a instanceof Query) {
+          queries[propName] = a;
         }
       });
-      const hostListeners = propertyMetadata[propName].filter(a => a && a instanceof HostListener);
-      hostListeners.forEach(hostListener => {
-        const args = hostListener.args || [];
-        host[`(${hostListener.eventName})`] = `${propName}(${args.join(',')})`;
-      });
-      const query = ListWrapper.findLast(propertyMetadata[propName], (a) => a instanceof Query);
-      if (query) {
-        queries[propName] = query;
-      }
     });
     return this._merge(dm, inputs, outputs, host, queries, directiveType);
   }
 
   private _extractPublicName(def: string) { return splitAtColon(def, [null, def])[1].trim(); }
 
-  private _dedupeBindings(bindings: string[]): string[] {
-    const names = new Set<string>();
-    const reversedResult: string[] = [];
-    // go last to first to allow later entries to overwrite previous entries
-    for (let i = bindings.length - 1; i >= 0; i--) {
-      const binding = bindings[i];
-      const name = this._extractPublicName(binding);
-      if (!names.has(name)) {
-        names.add(name);
-        reversedResult.push(binding);
-      }
-    }
-    return reversedResult.reverse();
-  }
-
   private _merge(
       directive: Directive, inputs: string[], outputs: string[], host: {[key: string]: string},
       queries: {[key: string]: any}, directiveType: Type<any>): Directive {
-    const mergedInputs =
-        this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);
-    const mergedOutputs =
-        this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);
+    const mergedInputs: string[] = inputs;
+
+    if (directive.inputs) {
+      const inputNames: string[] =
+          directive.inputs.map((def: string): string => this._extractPublicName(def));
+
+      inputs.forEach((inputDef: string) => {
+        const publicName = this._extractPublicName(inputDef);
+        if (inputNames.indexOf(publicName) > -1) {
+          throw new Error(
+              `Input '${publicName}' defined multiple times in '${stringify(directiveType)}'`);
+        }
+      });
+
+      mergedInputs.unshift(...directive.inputs);
+    }
+
+    const mergedOutputs: string[] = outputs;
+
+    if (directive.outputs) {
+      const outputNames: string[] =
+          directive.outputs.map((def: string): string => this._extractPublicName(def));
+
+      outputs.forEach((outputDef: string) => {
+        const publicName = this._extractPublicName(outputDef);
+        if (outputNames.indexOf(publicName) > -1) {
+          throw new Error(
+              `Output event '${publicName}' defined multiple times in '${stringify(directiveType)}'`);
+        }
+      });
+      mergedOutputs.unshift(...directive.outputs);
+    }
+
     const mergedHost = directive.host ? StringMapWrapper.merge(directive.host, host) : host;
     const mergedQueries =
         directive.queries ? StringMapWrapper.merge(directive.queries, queries) : queries;

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

@@ -6,19 +6,20 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
+import {Injectable} from '@angular/core';
+
+import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata} from './compile_metadata';
 import {createCheckBindingField, createCheckBindingStmt} from './compiler_util/binding_util';
 import {EventHandlerVars, convertActionBinding, convertPropertyBinding} from './compiler_util/expression_converter';
 import {triggerAnimation, writeToRenderer} from './compiler_util/render_util';
 import {CompilerConfig} from './config';
 import {Parser} from './expression_parser/parser';
-import {Identifiers, createIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
+import {Identifiers, resolveIdentifier} from './identifiers';
 import {DEFAULT_INTERPOLATION_CONFIG} from './ml_parser/interpolation_config';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan} from './parse_util';
-import {Console, LifecycleHooks} from './private_import_core';
+import {Console, LifecycleHooks, isDefaultChangeDetectionStrategy} from './private_import_core';
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {BindingParser} from './template_parser/binding_parser';
 import {BoundElementPropertyAst, BoundEventAst} from './template_parser/template_ast';
@@ -50,11 +51,9 @@ const RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap
  *
  * So far, only `@Input` and the lifecycle hooks have been implemented.
  */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveWrapperCompiler {
-  static dirWrapperClassName(id: CompileIdentifierMetadata) {
-    return `Wrapper_${identifierName(id)}`;
-  }
+  static dirWrapperClassName(id: CompileIdentifierMetadata) { return `Wrapper_${id.name}`; }
 
   constructor(
       private compilerConfig: CompilerConfig, private _exprParser: Parser,
@@ -69,7 +68,7 @@ export class DirectiveWrapperCompiler {
       addCheckInputMethod(inputFieldName, builder);
     });
     addNgDoCheckMethod(builder);
-    addCheckHostMethod(hostParseResult.hostProps, hostParseResult.hostListeners, builder);
+    addCheckHostMethod(hostParseResult.hostProps, builder);
     addHandleEventMethod(hostParseResult.hostListeners, builder);
     addSubscribeMethod(dirMeta, builder);
 
@@ -118,16 +117,17 @@ class DirectiveWrapperBuilder implements ClassBuilder {
           [
             new o.FnParam(
                 VIEW_VAR.name,
-                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
             new o.FnParam(
                 COMPONENT_VIEW_VAR.name,
-                o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+                o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
             new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
           ],
           this.detachStmts),
       new o.ClassMethod('ngOnDestroy', [], this.destroyStmts),
     ];
 
+
     const fields: o.ClassField[] = [
       new o.ClassField(EVENT_HANDLER_FIELD_NAME, o.FUNCTION_TYPE, [o.StmtModifier.Private]),
       new o.ClassField(CONTEXT_FIELD_NAME, o.importType(this.dirMeta.type)),
@@ -172,7 +172,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
     }
     if (builder.compilerConfig.logBindingUpdate) {
       onChangesStmts.push(
-          o.importExpr(createIdentifier(Identifiers.setBindingDebugInfoForChanges))
+          o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfoForChanges))
               .callFn(
                   [VIEW_VAR.prop('renderer'), RENDER_EL_VAR, o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])
               .toStmt());
@@ -198,7 +198,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
       'ngDoCheck',
       [
         new o.FnParam(
-            VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+            VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
         new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
         new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
       ],
@@ -214,7 +214,7 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
   if (builder.genChanges) {
     onChangeStatements.push(o.THIS_EXPR.prop(CHANGES_FIELD_NAME)
                                 .key(o.literal(input))
-                                .set(o.importExpr(createIdentifier(Identifiers.SimpleChange))
+                                .set(o.importExpr(resolveIdentifier(Identifiers.SimpleChange))
                                          .instantiate([field.expression, CURR_VALUE_VAR]))
                                 .toStmt());
   }
@@ -233,15 +233,14 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
 }
 
 function addCheckHostMethod(
-    hostProps: BoundElementPropertyAst[], hostEvents: BoundEventAst[],
-    builder: DirectiveWrapperBuilder) {
+    hostProps: BoundElementPropertyAst[], builder: DirectiveWrapperBuilder) {
   const stmts: o.Statement[] = [];
   const methodParams: o.FnParam[] = [
     new o.FnParam(
-        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(
         COMPONENT_VIEW_VAR.name,
-        o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
     new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
   ];
@@ -256,14 +255,14 @@ function addCheckHostMethod(
     if (hostProp.needsRuntimeSecurityContext) {
       securityContextExpr = o.variable(`secCtx_${methodParams.length}`);
       methodParams.push(new o.FnParam(
-          securityContextExpr.name, o.importType(createIdentifier(Identifiers.SecurityContext))));
+          securityContextExpr.name, o.importType(resolveIdentifier(Identifiers.SecurityContext))));
     }
     let checkBindingStmts: o.Statement[];
     if (hostProp.isAnimation) {
       const {updateStmts, detachStmts} = triggerAnimation(
-          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp, hostEvents,
+          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp,
           o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME)
-              .or(o.importExpr(createIdentifier(Identifiers.noop))),
+              .or(o.importExpr(resolveIdentifier(Identifiers.noop))),
           RENDER_EL_VAR, evalResult.currValExpr, field.expression);
       checkBindingStmts = updateStmts;
       builder.detachStmts.push(...detachStmts);
@@ -307,7 +306,7 @@ function addHandleEventMethod(hostListeners: BoundEventAst[], builder: Directive
 function addSubscribeMethod(dirMeta: CompileDirectiveMetadata, builder: DirectiveWrapperBuilder) {
   const methodParams: o.FnParam[] = [
     new o.FnParam(
-        VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
     new o.FnParam(EVENT_HANDLER_FIELD_NAME, o.DYNAMIC_TYPE)
   ];
   const stmts: o.Statement[] = [
@@ -349,10 +348,9 @@ function parseHostBindings(
   const errors: ParseError[] = [];
   const parser =
       new BindingParser(exprParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors);
-  const moduleUrl = identifierModuleUrl(dirMeta.type);
-  const sourceFileName = moduleUrl ?
-      `in Directive ${identifierName(dirMeta.type)} in ${moduleUrl}` :
-      `in Directive ${identifierName(dirMeta.type)}`;
+  const sourceFileName = dirMeta.type.moduleUrl ?
+      `in Directive ${dirMeta.type.name} in ${dirMeta.type.moduleUrl}` :
+      `in Directive ${dirMeta.type.name}`;
   const sourceFile = new ParseSourceFile('', sourceFileName);
   const sourceSpan = new ParseSourceSpan(
       new ParseLocation(sourceFile, null, null, null),

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

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
 import * as chars from '../chars';
-import {NumberWrapper} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
+import {NumberWrapper, isPresent} from '../facade/lang';
 
 export enum TokenType {
   Character,
@@ -22,7 +22,7 @@ export enum TokenType {
 
 const KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
 
-@CompilerInjectable()
+@Injectable()
 export class Lexer {
   tokenize(text: string): Token[] {
     const scanner = new _Scanner(text);
@@ -120,7 +120,7 @@ function newErrorToken(index: number, message: string): Token {
   return new Token(index, TokenType.Error, 0, message);
 }
 
-export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
+export var EOF: Token = new Token(-1, TokenType.Character, 0, '');
 
 class _Scanner {
   length: number;
@@ -241,7 +241,7 @@ class _Scanner {
       this.advance();
       str += two;
     }
-    if (threeCode != null && this.peek == threeCode) {
+    if (isPresent(threeCode) && this.peek == threeCode) {
       this.advance();
       str += three;
     }

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

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