docs(changelog): add changelog for 2.4.3

The change avoids the compiler CLI internal API from mismatching the following case as lazy loading

```
import { NonLazyLoadedModule } from './non-lazy-loaded/non-lazy-loaded.module';

export function getNonLazyLoadedModule() { return NonLazyLoadedModule; }

export const routes = [
{ path: '/some-path', loadChildren: getNonLazyLoadedModule }
];
```

The output of the check is later passed to `RouteDef.fromString()`, so, it makes sense to be only a string.

Fixes angular/angular-cli#3204

.pullapprove.yml

@@ -0,0 +1,32 @@
+# 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,3 +1,58 @@
+<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)
+* **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)
 

DEVELOPER.md

@@ -74,6 +74,15 @@ use in these instructions.
 *Option 2*: defining a bash alias like `alias nbin='PATH=$(npm bin):$PATH'` as detailed in this
 [Stackoverflow answer](http://stackoverflow.com/questions/9679932/how-to-use-package-installed-locally-in-node-modules/15157360#15157360) and used like this: e.g., `nbin gulp build`.
 
+## Installing Bower Modules
+
+Now run `bower` to install additional dependencies:
+
+```shell
+# Install other Angular project dependencies (bower.json)
+bower install
+```
+
 ## Windows only
 
 In order to create the right symlinks, run **as administrator**:
@@ -124,7 +133,8 @@ If you happen to modify the public API of Angular, API golden files must be upda
 $ gulp public-api:update
 ```
 
-Note: The command `./test.sh tools` fails when the API doesn't match the golden files.
+Note: The command `gulp public-api:enforce` fails when the API doesn't match the golden files. Make sure to rebuild
+the project before trying to verify after an API change.
 
 ## <a name="clang-format"></a> Formatting your source code
 
@@ -137,6 +147,14 @@ 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.
@@ -155,3 +173,6 @@ 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.

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 {isPresent, stringify} from '../facade/lang';
+import {stringify} from '../facade/lang';
 
 /**
  * @ngModule CommonModule
@@ -25,6 +25,8 @@ import {isPresent, stringify} from '../facade/lang';
  *     <some-element [ngClass]="{'first': true, 'second': true, 'third': false}">...</some-element>
  *
  *     <some-element [ngClass]="stringExp|arrayExp|objExp">...</some-element>
+ *
+ *     <some-element [ngClass]="{'class1 class2 class3' : true}">...</some-element>
  * ```
  *
  * @description
@@ -132,7 +134,7 @@ export class NgClass implements DoCheck {
         (<any>rawClassVal).forEach((klass: string) => this._toggleClass(klass, !isCleanup));
       } else {
         Object.keys(rawClassVal).forEach(klass => {
-          if (isPresent(rawClassVal[klass])) this._toggleClass(klass, !isCleanup);
+          if (rawClassVal[klass] != null) 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} from '@angular/core';
+import {ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, Directive, DoCheck, EmbeddedViewRef, Input, IterableDiffer, IterableDiffers, OnChanges, SimpleChanges, TemplateRef, TrackByFn, ViewContainerRef, isDevMode} from '@angular/core';
 
 import {getTypeNameForDebugging} from '../facade/lang';
 
@@ -89,9 +89,23 @@ export class NgForRow {
 @Directive({selector: '[ngFor][ngForOf]'})
 export class NgFor implements DoCheck, OnChanges {
   @Input() ngForOf: any;
-  @Input() ngForTrackBy: TrackByFn;
+  @Input()
+  set ngForTrackBy(fn: TrackByFn) {
+    if (isDevMode() && fn != null && typeof fn !== 'function') {
+      // TODO(vicb): use a log service once there is a public one available
+      if (<any>console && <any>console.warn) {
+        console.warn(
+            `trackBy must be a function, but received ${JSON.stringify(fn)}. ` +
+            `See https://angular.io/docs/ts/latest/api/common/index/NgFor-directive.html#!#change-propagation for more information.`);
+      }
+    }
+    this._trackByFn = fn;
+  }
+
+  get ngForTrackBy(): TrackByFn { return this._trackByFn; }
 
   private _differ: IterableDiffer = null;
+  private _trackByFn: TrackByFn;
 
   constructor(
       private _viewContainer: ViewContainerRef, private _template: TemplateRef<NgForRow>,
@@ -119,7 +133,7 @@ export class NgFor implements DoCheck, OnChanges {
     }
   }
 
-  ngDoCheck() {
+  ngDoCheck(): void {
     if (this._differ) {
       const changes = this._differ.diff(this.ngForOf);
       if (changes) this._applyChanges(changes);

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

@@ -21,10 +21,9 @@ import {SwitchView} from './ng_switch';
  * @howToUse
  * ```
  * <some-element [ngPlural]="value">
- *   <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>
+ *   <template ngPluralCase="=0">there is nothing</template>
+ *   <template ngPluralCase="=1">there is one</template>
+ *   <template ngPluralCase="few">there are a few</template>
  * </some-element>
  * ```
  *
@@ -90,8 +89,8 @@ export class NgPlural {
  * @howToUse
  * ```
  * <some-element [ngPlural]="value">
- *   <ng-container *ngPluralCase="'=0'">...</ng-container>
- *   <ng-container *ngPluralCase="'other'">...</ng-container>
+ *   <template ngPluralCase="=0">...</template>
+ *   <template ngPluralCase="other">...</template>
  * </some-element>
  *```
  *

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

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

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

@@ -8,7 +8,7 @@
 
 import {Inject, LOCALE_ID, Pipe, PipeTransform, Type} from '@angular/core';
 
-import {NumberWrapper, isBlank, isPresent} from '../facade/lang';
+import {NumberWrapper} from '../facade/lang';
 
 import {NumberFormatStyle, NumberFormatter} from './intl';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
@@ -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 (isBlank(value)) return null;
+  if (value == null) 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 (isPresent(parts[1])) {  // min integer digits
+    if (parts[1] != null) {  // min integer digits
       minInt = NumberWrapper.parseIntAutoRadix(parts[1]);
     }
-    if (isPresent(parts[3])) {  // min fraction digits
+    if (parts[3] != null) {  // min fraction digits
       minFraction = NumberWrapper.parseIntAutoRadix(parts[3]);
     }
-    if (isPresent(parts[5])) {  // max fraction digits
+    if (parts[5] != null) {  // max fraction digits
       maxFraction = NumberWrapper.parseIntAutoRadix(parts[5]);
     }
   }

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

@@ -7,7 +7,6 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
-import {isBlank} from '../facade/lang';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
@@ -58,7 +57,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 (isBlank(value)) return value;
+    if (value == null) return value;
 
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentError(SlicePipe, value);

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

@@ -7,7 +7,7 @@
  */
 
 import {CommonModule} from '@angular/common';
-import {Component, ContentChild, TemplateRef} from '@angular/core';
+import {Component} 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,10 +29,7 @@ export function main() {
 
     beforeEach(() => {
       TestBed.configureTestingModule({
-        declarations: [
-          TestComponent,
-          ComponentUsingTestComponent,
-        ],
+        declarations: [TestComponent],
         imports: [CommonModule],
       });
     });
@@ -77,7 +74,7 @@ export function main() {
        }));
 
     it('should iterate over an array of objects', async(() => {
-         const template = '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
+         const template = '<ul><li *ngFor="let item of items">{{item["name"]}};</li></ul>';
          fixture = createTestComponent(template);
 
          // INIT
@@ -95,7 +92,7 @@ export function main() {
        }));
 
     it('should gracefully handle nulls', async(() => {
-         const template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
+         const template = '<ul><li *ngFor="let item of null">{{item}};</li></ul>';
          fixture = createTestComponent(template);
 
          detectChangesAndExpectText('');
@@ -140,12 +137,8 @@ export function main() {
        }));
 
     it('should repeat over nested arrays', async(() => {
-         const template = '<div>' +
-             '<div template="ngFor let item of items">' +
-             '<div template="ngFor let subitem of item">' +
-             '{{subitem}}-{{item.length}};' +
-             '</div>|' +
-             '</div>' +
+         const template = '<div *ngFor="let item of items">' +
+             '<div *ngFor="let subitem of item">{{subitem}}-{{item.length}};</div>|' +
              '</div>';
          fixture = createTestComponent(template);
 
@@ -157,10 +150,9 @@ export function main() {
        }));
 
     it('should repeat over nested arrays with no intermediate element', async(() => {
-         const template = '<div><template ngFor let-item [ngForOf]="items">' +
-             '<div template="ngFor let subitem of item">' +
-             '{{subitem}}-{{item.length}};' +
-             '</div></template></div>';
+         const template = '<div *ngFor="let item of items">' +
+             '<div *ngFor="let subitem of item">{{subitem}}-{{item.length}};</div>' +
+             '</div>';
          fixture = createTestComponent(template);
 
          getComponent().items = [['a', 'b'], ['c']];
@@ -170,10 +162,11 @@ export function main() {
          detectChangesAndExpectText('e-1;f-2;g-2;');
        }));
 
-    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>`;
+    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>`;
 
          fixture = createTestComponent(template);
 
@@ -189,8 +182,7 @@ export function main() {
        }));
 
     it('should display indices correctly', async(() => {
-         const template =
-             '<div><span template="ngFor: let item of items; let i=index">{{i.toString()}}</span></div>';
+         const template = '<span *ngFor ="let item of items; let i=index">{{i.toString()}}</span>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
@@ -202,7 +194,7 @@ export function main() {
 
     it('should display first item correctly', async(() => {
          const template =
-             '<div><span template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</span></div>';
+             '<span *ngFor="let item of items; let isFirst=first">{{isFirst.toString()}}</span>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -214,7 +206,7 @@ export function main() {
 
     it('should display last item correctly', async(() => {
          const template =
-             '<div><span template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</span></div>';
+             '<span *ngFor="let item of items; let isLast=last">{{isLast.toString()}}</span>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -226,7 +218,7 @@ export function main() {
 
     it('should display even items correctly', async(() => {
          const template =
-             '<div><span template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</span></div>';
+             '<span *ngFor="let item of items; let isEven=even">{{isEven.toString()}}</span>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2];
@@ -238,7 +230,7 @@ export function main() {
 
     it('should display odd items correctly', async(() => {
          const template =
-             '<div><span template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</span></div>';
+             '<span *ngFor="let item of items; let isOdd=odd">{{isOdd.toString()}}</span>';
          fixture = createTestComponent(template);
 
          getComponent().items = [0, 1, 2, 3];
@@ -249,54 +241,57 @@ export function main() {
        }));
 
     it('should allow to use a custom template', async(() => {
-         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'];
+         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'];
          fixture.detectChanges();
-         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+         detectChangesAndExpectText('0: a;1: b;2: c;');
        }));
 
     it('should use a default template if a custom one is null', async(() => {
-         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'];
+         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'];
          fixture.detectChanges();
-         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+         detectChangesAndExpectText('0: a;1: b;2: c;');
        }));
 
     it('should use a custom template when both default and a custom one are present', async(() => {
-         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'];
+         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'];
          fixture.detectChanges();
-         expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+         detectChangesAndExpectText('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 =
-               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
+               `<p *ngFor="let item of items; trackBy: trackByContext.bind(this)"></p>`;
            fixture = createTestComponent(template);
 
            thisArg = null;
@@ -306,9 +301,7 @@ export function main() {
 
       it('should not replace tracked items', async(() => {
            const template =
-               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
-               <p>{{items[i]}}</p>
-              </template>`;
+               `<p *ngFor="let item of items; trackBy: trackById; let i=index">{{items[i]}}</p>`;
            fixture = createTestComponent(template);
 
            const buildItemList = () => {
@@ -324,7 +317,7 @@ export function main() {
 
       it('should update implicit local variable on view', async(() => {
            const template =
-               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               `<div *ngFor="let item of items; trackBy: trackById">{{item['color']}}</div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = [{'id': 'a', 'color': 'blue'}];
@@ -333,9 +326,10 @@ export function main() {
            getComponent().items = [{'id': 'a', 'color': 'red'}];
            detectChangesAndExpectText('red');
          }));
+
       it('should move items around and keep them updated ', async(() => {
            const template =
-               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               `<div *ngFor="let item of items; trackBy: trackById">{{item['color']}}</div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = [{'id': 'a', 'color': 'blue'}, {'id': 'b', 'color': 'yellow'}];
@@ -346,8 +340,7 @@ export function main() {
          }));
 
       it('should handle added and removed items properly when tracking by index', async(() => {
-           const template =
-               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
+           const template = `<div *ngFor="let item of items; trackBy: trackByIndex">{{item}}</div>`;
            fixture = createTestComponent(template);
 
            getComponent().items = ['a', 'b', 'c', 'd'];
@@ -367,21 +360,16 @@ class Foo {
 
 @Component({selector: 'test-cmp', template: ''})
 class TestComponent {
-  @ContentChild(TemplateRef) contentTpl: TemplateRef<Object>;
+  value: any;
   items: any[] = [1, 2];
   trackById(index: number, item: any): string { return item['id']; }
   trackByIndex(index: number, item: any): number { return index; }
   trackByContext(): void { thisArg = this; }
 }
 
-@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>';
+const TEMPLATE = '<div><span *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,6 +9,7 @@
 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';
 
@@ -28,131 +29,114 @@ export function main() {
     });
 
     it('should work in a template attribute', async(() => {
-         const template = '<div><span template="ngIf booleanCondition">hello</span></div>';
+         const template = '<span *ngIf="booleanCondition">hello</span>';
          fixture = createTestComponent(template);
-
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
        }));
 
-    it('should work in a template element', async(() => {
-         const template =
-             '<div><template [ngIf]="booleanCondition"><span>hello2</span></template></div>';
-
+    it('should work on a template element', async(() => {
+         const template = '<template [ngIf]="booleanCondition">hello2</template>';
          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 = '<div><span template="ngIf booleanCondition">hello</span></div>';
-
+         const template = '<span *ngIf="booleanCondition">hello</span>';
          fixture = createTestComponent(template);
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().booleanCondition = true;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
        }));
 
     it('should handle nested if correctly', async(() => {
          const template =
-             '<div><template [ngIf]="booleanCondition"><span *ngIf="nestedBooleanCondition">hello</span></template></div>';
+             '<div *ngIf="booleanCondition"><span *ngIf="nestedBooleanCondition">hello</span></div>';
 
          fixture = createTestComponent(template);
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().booleanCondition = true;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().nestedBooleanCondition = false;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
 
          getComponent().nestedBooleanCondition = true;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().booleanCondition = false;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(0);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(0);
          expect(fixture.nativeElement).toHaveText('');
        }));
 
     it('should update several nodes with if', async(() => {
-         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>';
+         const template = '<span *ngIf="numberCondition + 1 >= 2">helloNumber</span>' +
+             '<span *ngIf="stringCondition == \'foo\'">helloString</span>' +
+             '<span *ngIf="functionCondition(stringCondition, numberCondition)">helloFunction</span>';
 
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(3);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(3);
          expect(getDOM().getText(fixture.nativeElement))
              .toEqual('helloNumberhelloStringhelloFunction');
 
          getComponent().numberCondition = 0;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('helloString');
 
          getComponent().numberCondition = 1;
          getComponent().stringCondition = 'bar';
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         expect(fixture.debugElement.queryAll(By.css('span')).length).toEqual(1);
          expect(fixture.nativeElement).toHaveText('helloNumber');
        }));
 
-    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>';
+    it('should not add the element twice if the condition goes from truthy to truthy', async(() => {
+         const template = '<span *ngIf="numberCondition">hello</span>';
 
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         let els = fixture.debugElement.queryAll(By.css('span'));
+         expect(els.length).toEqual(1);
+         getDOM().addClass(els[0].nativeElement, 'marker');
          expect(fixture.nativeElement).toHaveText('hello');
 
          getComponent().numberCondition = 2;
          fixture.detectChanges();
-         expect(getDOM().querySelectorAll(fixture.nativeElement, 'span').length).toEqual(1);
+         els = fixture.debugElement.queryAll(By.css('span'));
+         expect(els.length).toEqual(1);
+         expect(getDOM().hasClass(els[0].nativeElement, 'marker')).toBe(true);
+
          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

@@ -33,11 +33,10 @@ export function main() {
     });
 
     it('should display the template according to the exact value', async(() => {
-         const template = '<div>' +
-             '<ul [ngPlural]="switchValue">' +
+         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></div>';
+             '</ul>';
 
          fixture = createTestComponent(template);
 
@@ -51,10 +50,9 @@ 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 = '<div>' +
-             '<ul [ngPlural]="switchValue">' +
+         const template = '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="=0"><li>{{ switchValue }}</li></template>' +
-             '</ul></div>';
+             '</ul>';
 
          fixture = createTestComponent(template);
 
@@ -64,11 +62,10 @@ export function main() {
 
 
     it('should be applicable to <ng-container> elements', async(() => {
-         const template = '<div>' +
-             '<ng-container [ngPlural]="switchValue">' +
+         const template = '<ng-container [ngPlural]="switchValue">' +
              '<template ngPluralCase="=0">you have no messages.</template>' +
              '<template ngPluralCase="=1">you have one message.</template>' +
-             '</ng-container></div>';
+             '</ng-container>';
 
          fixture = createTestComponent(template);
 
@@ -80,11 +77,10 @@ export function main() {
        }));
 
     it('should display the template according to the category', async(() => {
-         const template = '<div>' +
-             '<ul [ngPlural]="switchValue">' +
+         const template = '<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></div>';
+             '</ul>';
 
          fixture = createTestComponent(template);
 
@@ -96,11 +92,10 @@ export function main() {
        }));
 
     it('should default to other when no matches are found', async(() => {
-         const template = '<div>' +
-             '<ul [ngPlural]="switchValue">' +
+         const template = '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
              '<template ngPluralCase="other"><li>default message.</li></template>' +
-             '</ul></div>';
+             '</ul>';
 
          fixture = createTestComponent(template);
 
@@ -109,11 +104,10 @@ export function main() {
        }));
 
     it('should prioritize value matches over category matches', async(() => {
-         const template = '<div>' +
-             '<ul [ngPlural]="switchValue">' +
+         const template = '<ul [ngPlural]="switchValue">' +
              '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
              '<template ngPluralCase="=2">you have two messages.</template>' +
-             '</ul></div>';
+             '</ul>';
 
          fixture = createTestComponent(template);
 

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

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

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

@@ -34,29 +34,22 @@ export function main() {
       });
     });
 
-    it('should do nothing if templateRef is null', async(() => {
-         const template = `<template [ngTemplateOutlet]="null"></template>`;
+    it('should do nothing if templateRef is `null`', async(() => {
+         const template = `<ng-container [ngTemplateOutlet]="null"></ng-container>`;
          fixture = createTestComponent(template);
-
          detectChangesAndExpectText('');
        }));
 
     it('should insert content specified by TemplateRef', async(() => {
-         const template =
-             `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+         const template = `<template #tpl>foo</template>` +
+             `<ng-container [ngTemplateOutlet]="tpl"></ng-container>`;
          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><template [ngTemplateOutlet]="currentTplRef"></template>`;
+    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>`;
          fixture = createTestComponent(template);
          fixture.detectChanges();
          const refs = fixture.debugElement.children[0].references['refs'];
@@ -70,7 +63,8 @@ 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><template [ngTemplateOutlet]="currentTplRef"></template>`;
+             `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs>` +
+             `<ng-container [ngTemplateOutlet]="currentTplRef"></ng-container>`;
          fixture = createTestComponent(template);
 
          fixture.detectChanges();
@@ -83,70 +77,47 @@ export function main() {
          detectChangesAndExpectText('bar');
        }));
 
-    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>`;
+    it('should display template if context is `null`', async(() => {
+         const template = `<template #tpl>foo</template>` +
+             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="null"></ng-container>`;
          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 =
-             `<tpl-refs #refs="tplRefs"><template let-foo="foo"><span>{{foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+         const template = `<template let-foo="foo" #tpl>{{foo}}</template>` +
+             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="context"></ng-container>`;
          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 =
-             `<tpl-refs #refs="tplRefs"><template let-ctx><span>{{ctx.foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+    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>`;
          fixture = createTestComponent(template);
-
-         fixture.detectChanges();
-
-         const refs = fixture.debugElement.children[0].references['refs'];
-         setTplRef(refs.tplRefs.first);
-
-         fixture.componentInstance.context = {$implicit: fixture.componentInstance.context};
-         detectChangesAndExpectText('bar');
+         fixture.componentInstance.context = {$implicit: {foo: 'bra'}};
+         detectChangesAndExpectText('bra');
        }));
 
     it('should reflect context re-binding', async(() => {
-         const template =
-             `<tpl-refs #refs="tplRefs"><template let-shawshank="shawshank"><span>{{shawshank}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+         const template = `<template let-shawshank="shawshank" #tpl>{{shawshank}}</template>` +
+             `<ng-container [ngTemplateOutlet]="tpl" [ngOutletContext]="context"></ng-container>`;
          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>>;
@@ -162,4 +133,4 @@ function createTestComponent(template: string): ComponentFixture<TestComponent>
   return TestBed.overrideComponent(TestComponent, {set: {template: template}})
       .configureTestingModule({schemas: [NO_ERRORS_SCHEMA]})
       .createComponent(TestComponent);
-}
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Component, NgModule} from '@angular/core';
+import {RouterModule} from '@angular/router';
+
+@Component({selector: '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

@@ -16,7 +16,10 @@ export class LazyFeatureComponent {
 @NgModule({
   imports: [RouterModule.forChild([
     {path: '', component: LazyFeatureComponent, pathMatch: 'full'},
-    {path: 'feature', loadChildren: './feature.module#FeatureModule'}
+    {path: 'feature', loadChildren: './feature.module#FeatureModule'}, {
+      path: 'nested-feature',
+      loadChildren: './lazy-feature-nested.module#LazyFeatureNestedModule'
+    }
   ])],
   declarations: [LazyFeatureComponent]
 })

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

@@ -191,6 +191,8 @@ function lazyRoutesTest() {
     './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'

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

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

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

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

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

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

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

@@ -11,7 +11,6 @@
  * Intended to be used in a build step.
  */
 import * as compiler from '@angular/compiler';
-import {ViewEncapsulation} from '@angular/core';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import {readFileSync} from 'fs';
 import * as path from 'path';
@@ -19,7 +18,6 @@ import * as ts from 'typescript';
 
 import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
 import {PathMappedCompilerHost} from './path_mapped_compiler_host';
-import {Console} from './private_import_core';
 
 const GENERATED_META_FILES = /\.json$/;
 

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

@@ -15,8 +15,6 @@
 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';
@@ -63,29 +61,37 @@ export function listLazyRoutesOfModule(
   const className = entryRouteDef.className;
 
   // List loadChildren of this single module.
-  const staticSymbol = reflector.findDeclaration(modulePath, className, containingFile);
+  const appStaticSymbol = reflector.findDeclaration(modulePath, className, containingFile);
   const ROUTES = reflector.findDeclaration(ROUTER_MODULE_PATH, ROUTER_ROUTES_SYMBOL_NAME);
   const lazyRoutes: LazyRoute[] =
-      _extractLazyRoutesFromStaticModule(staticSymbol, reflector, host, ROUTES);
-  const routes: LazyRouteMap = {};
+      _extractLazyRoutesFromStaticModule(appStaticSymbol, reflector, host, ROUTES);
 
-  lazyRoutes.forEach((lazyRoute: LazyRoute) => {
-    const route: string = lazyRoute.routeDef.toString();
-    _assertRoute(routes, lazyRoute);
-    routes[route] = lazyRoute;
+  const allLazyRoutes = lazyRoutes.reduce(
+      function includeLazyRouteAndSubRoutes(allRoutes: LazyRouteMap, lazyRoute: LazyRoute):
+          LazyRouteMap {
+            const route: string = lazyRoute.routeDef.toString();
+            _assertRoute(allRoutes, lazyRoute);
+            allRoutes[route] = lazyRoute;
 
-    const lazyModuleSymbol = reflector.findDeclaration(
-        lazyRoute.absoluteFilePath, lazyRoute.routeDef.className || 'default');
-    const subRoutes = _extractLazyRoutesFromStaticModule(lazyModuleSymbol, reflector, host, ROUTES);
+            // 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;
+            }
 
-    // Populate the map using the routes we just found.
-    subRoutes.forEach(subRoute => {
-      _assertRoute(routes, subRoute);
-      routes[subRoute.routeDef.toString()] = subRoute;
-    });
-  });
+            const lazyModuleSymbol = reflector.findDeclaration(
+                lazyRoute.absoluteFilePath, lazyRoute.routeDef.className || 'default');
 
-  return routes;
+            const subRoutes =
+                _extractLazyRoutesFromStaticModule(lazyModuleSymbol, reflector, host, ROUTES);
+
+            return subRoutes.reduce(includeLazyRouteAndSubRoutes, allRoutes);
+          },
+      {});
+
+  return allLazyRoutes;
 }
 
 
@@ -192,7 +198,7 @@ function _collectRoutes(
  */
 function _collectLoadChildren(routes: Route[]): string[] {
   return routes.reduce((m, r) => {
-    if (r.loadChildren) {
+    if (r.loadChildren && typeof r.loadChildren === 'string') {
       return m.concat(r.loadChildren);
     } else if (Array.isArray(r)) {
       return m.concat(_collectLoadChildren(r));

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

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

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

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

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

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

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

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

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

@@ -6,8 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {SchemaMetadata} from '@angular/core';
-
 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, CompileTypeSummary, createHostComponentMeta, identifierModuleUrl, identifierName} from '../compile_metadata';

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

@@ -10,8 +10,8 @@ import {Attribute, Component, ContentChild, ContentChildren, Directive, Host, Ho
 
 import {ReflectorReader} from '../private_import_core';
 
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
+import {StaticSymbol} from './static_symbol';
+import {StaticSymbolResolver} from './static_symbol_resolver';
 
 const ANGULAR_IMPORT_LOCATIONS = {
   coreDecorators: '@angular/core/src/metadata',
@@ -310,6 +310,7 @@ export class StaticReflector implements ReflectorReader {
             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)));
               }
@@ -499,15 +500,15 @@ export class StaticReflector implements ReflectorReader {
                     return context;
                   }
                   const argExpressions: any[] = expression['arguments'] || [];
-                  const args =
-                      argExpressions.map(arg => simplifyInContext(context, arg, depth + 1));
                   let converter = self.conversionMap.get(staticSymbol);
                   if (converter) {
+                    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, args);
+                    return simplifyCall(staticSymbol, targetFunction, argExpressions);
                   }
                 }
                 break;
@@ -651,10 +652,6 @@ class PopulatedScope extends BindingScope {
   }
 }
 
-function sameSymbol(a: StaticSymbol, b: StaticSymbol): boolean {
-  return a === b;
-}
-
 function shouldIgnore(value: any): boolean {
   return value && value.__symbolic == 'ignore';
 }

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

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import {CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
+
 import {Summary, SummaryResolver} from '../summary_resolver';
 
 import {StaticSymbol, StaticSymbolCache} from './static_symbol';

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

@@ -5,16 +5,16 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
+import {CompileNgModuleSummary, CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
 import {Summary, SummaryResolver} from '../summary_resolver';
 import {ValueTransformer, visitValue} from '../util';
 
-import {GeneratedFile} from './generated_file';
 import {StaticSymbol, StaticSymbolCache} from './static_symbol';
 import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
 
 const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 
+
 export interface AotSummarySerializerHost {
   /**
    * Returns the output file path of a source file.
@@ -180,4 +180,4 @@ class Deserializer extends ValueTransformer {
       return super.visitStringMap(map, context);
     }
   }
-}
+}

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

@@ -5,7 +5,6 @@
  * 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 {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';

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

@@ -8,7 +8,7 @@
 
 
 import * as cdAst from '../expression_parser/ast';
-import {isBlank, isPresent} from '../facade/lang';
+import {isBlank} from '../facade/lang';
 import {Identifiers, createIdentifier} from '../identifiers';
 import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';
@@ -338,7 +338,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 (isPresent(varExpr)) {
+        if (varExpr) {
           result = varExpr.callFn(args);
         }
       }
@@ -374,7 +374,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 (isPresent(varExpr)) {
+      if (varExpr) {
         throw new Error('Cannot assign to a reference or variable!');
       }
     }

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

@@ -8,7 +8,7 @@
 
 import {Component, ViewEncapsulation} from '@angular/core';
 
-import {CompileAnimationEntryMetadata, CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata, CompileTypeMetadata} from './compile_metadata';
+import {CompileAnimationEntryMetadata, CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata} from './compile_metadata';
 import {CompilerConfig} from './config';
 import {isBlank, isPresent, stringify} from './facade/lang';
 import {CompilerInjectable} from './injectable';

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

@@ -14,8 +14,6 @@ import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 import {splitAtColon} from './util';
 
-
-
 /*
  * Resolve a `Type` for {@link Directive}.
  *

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

@@ -18,7 +18,7 @@ import {DEFAULT_INTERPOLATION_CONFIG} from './ml_parser/interpolation_config';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan} from './parse_util';
-import {Console, LifecycleHooks, isDefaultChangeDetectionStrategy} from './private_import_core';
+import {Console, LifecycleHooks} from './private_import_core';
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {BindingParser} from './template_parser/binding_parser';
 import {BoundElementPropertyAst, BoundEventAst} from './template_parser/template_ast';
@@ -128,7 +128,6 @@ class DirectiveWrapperBuilder implements ClassBuilder {
       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)),

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

@@ -7,7 +7,7 @@
  */
 
 import * as chars from '../chars';
-import {NumberWrapper, isPresent} from '../facade/lang';
+import {NumberWrapper} from '../facade/lang';
 import {CompilerInjectable} from '../injectable';
 
 export enum TokenType {
@@ -120,7 +120,7 @@ function newErrorToken(index: number, message: string): Token {
   return new Token(index, TokenType.Error, 0, message);
 }
 
-export var EOF: Token = new Token(-1, TokenType.Character, 0, '');
+export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
 
 class _Scanner {
   length: number;
@@ -241,7 +241,7 @@ class _Scanner {
       this.advance();
       str += two;
     }
-    if (isPresent(threeCode) && this.peek == threeCode) {
+    if (threeCode != null && this.peek == threeCode) {
       this.advance();
       str += three;
     }

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

@@ -53,20 +53,22 @@ enum _VisitorMode {
  * @internal
  */
 class _Visitor implements html.Visitor {
+  private _depth: number;
+
   // <el i18n>...</el>
   private _inI18nNode: boolean;
-  private _depth: number;
   private _inImplicitNode: boolean;
 
   // <!--i18n-->...<!--/i18n-->
+  private _inI18nBlock: boolean;
   private _blockMeaningAndDesc: string;
   private _blockChildren: html.Node[];
   private _blockStartDepth: number;
-  private _inI18nBlock: boolean;
 
   // {<icu message>}
   private _inIcu: boolean;
 
+  // set to void 0 when not in a section
   private _msgCountAtSectionStart: number;
   private _errors: I18nError[];
   private _mode: _VisitorMode;
@@ -208,50 +210,31 @@ class _Visitor implements html.Visitor {
     this._depth++;
     const wasInI18nNode = this._inI18nNode;
     const wasInImplicitNode = this._inImplicitNode;
-    let childNodes: html.Node[];
+    let childNodes: html.Node[] = [];
+    let translatedChildNodes: html.Node[];
 
-    // Extract only top level nodes with the (implicit) "i18n" attribute if not in a block or an ICU
-    // message
+    // Extract:
+    // - top level nodes with the (implicit) "i18n" attribute if not already in a section
+    // - ICU messages
     const i18nAttr = _getI18nAttr(el);
+    const i18nMeta = i18nAttr ? i18nAttr.value : '';
     const isImplicit = this._implicitTags.some(tag => el.name === tag) && !this._inIcu &&
         !this._isInTranslatableSection;
     const isTopLevelImplicit = !wasInImplicitNode && isImplicit;
-    this._inImplicitNode = this._inImplicitNode || isImplicit;
+    this._inImplicitNode = wasInImplicitNode || isImplicit;
 
     if (!this._isInTranslatableSection && !this._inIcu) {
-      if (i18nAttr) {
-        // explicit translation
+      if (i18nAttr || isTopLevelImplicit) {
         this._inI18nNode = true;
-        const message = this._addMessage(el.children, i18nAttr.value);
-        childNodes = this._translateMessage(el, message);
-      } else if (isTopLevelImplicit) {
-        // implicit translation
-        this._inI18nNode = true;
-        const message = this._addMessage(el.children);
-        childNodes = this._translateMessage(el, message);
+        const message = this._addMessage(el.children, i18nMeta);
+        translatedChildNodes = this._translateMessage(el, message);
       }
 
       if (this._mode == _VisitorMode.Extract) {
         const isTranslatable = i18nAttr || isTopLevelImplicit;
-        if (isTranslatable) {
-          this._openTranslatableSection(el);
-        }
+        if (isTranslatable) this._openTranslatableSection(el);
         html.visitAll(this, el.children);
-        if (isTranslatable) {
-          this._closeTranslatableSection(el, el.children);
-        }
-      }
-
-      if (this._mode === _VisitorMode.Merge && !i18nAttr && !isTopLevelImplicit) {
-        childNodes = [];
-        el.children.forEach(child => {
-          const visited = child.visit(this, context);
-          if (visited && !this._isInTranslatableSection) {
-            // Do not add the children from translatable sections (= i18n blocks here)
-            // They will be added when the section is close (i.e. on `<!-- /i18n -->`)
-            childNodes = childNodes.concat(visited);
-          }
-        });
+        if (isTranslatable) this._closeTranslatableSection(el, el.children);
       }
     } else {
       if (i18nAttr || isTopLevelImplicit) {
@@ -263,19 +246,18 @@ class _Visitor implements html.Visitor {
         // Descend into child nodes for extraction
         html.visitAll(this, el.children);
       }
+    }
 
-      if (this._mode == _VisitorMode.Merge) {
-        // Translate attributes in ICU messages
-        childNodes = [];
-        el.children.forEach(child => {
-          const visited = child.visit(this, context);
-          if (visited && !this._isInTranslatableSection) {
-            // Do not add the children from translatable sections (= i18n blocks here)
-            // They will be added when the section is close (i.e. on `<!-- /i18n -->`)
-            childNodes = childNodes.concat(visited);
-          }
-        });
-      }
+    if (this._mode === _VisitorMode.Merge) {
+      const visitNodes = translatedChildNodes || el.children;
+      visitNodes.forEach(child => {
+        const visited = child.visit(this, context);
+        if (visited && !this._isInTranslatableSection) {
+          // Do not add the children from translatable sections (= i18n blocks here)
+          // They will be added later in this loop when the block closes (i.e. on `<!-- /i18n -->`)
+          childNodes = childNodes.concat(visited);
+        }
+      });
     }
 
     this._visitAttributesOf(el);
@@ -285,7 +267,6 @@ class _Visitor implements html.Visitor {
     this._inImplicitNode = wasInImplicitNode;
 
     if (this._mode === _VisitorMode.Merge) {
-      // There are no childNodes in translatable sections - those nodes will be replace anyway
       const translatedAttrs = this._translateAttributes(el);
       return new html.Element(
           el.name, translatedAttrs, childNodes, el.sourceSpan, el.startSourceSpan,
@@ -432,7 +413,7 @@ class _Visitor implements html.Visitor {
 
   /**
    * A translatable section could be:
-   * - a translatable element,
+   * - the content of translatable element,
    * - nodes between `<!-- i18n -->` and `<!-- /i18n -->` comments
    */
   private get _isInTranslatableSection(): boolean {

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ANALYZE_FOR_ENTRY_COMPONENTS, AnimationTransitionEvent, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, ElementRef, Injector, LOCALE_ID, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT, TemplateRef, ViewContainerRef, ViewEncapsulation} from '@angular/core';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, ElementRef, Injector, LOCALE_ID, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT, TemplateRef, ViewContainerRef, ViewEncapsulation} from '@angular/core';
 
 import {StaticSymbol} from './aot/static_symbol';
 import {CompileIdentifierMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName} from './compile_metadata';

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

@@ -283,7 +283,7 @@ class _TreeBuilder {
     const tagDef = this.getTagDefinition(el.name);
     const {parent, container} = this._getParentElementSkippingContainers();
 
-    if (isPresent(parent) && tagDef.requireExtraParent(parent.name)) {
+    if (parent && tagDef.requireExtraParent(parent.name)) {
       const newParent = new html.Element(
           tagDef.parentToAdd, [], [], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
       this._insertBeforeContainer(parent, container, newParent);

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

@@ -9,7 +9,7 @@
 import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName, tokenName, tokenReference} from './compile_metadata';
 import {createDiTokenExpression} from './compiler_util/identifier_util';
 import {isPresent} from './facade/lang';
-import {Identifiers, createIdentifier, createIdentifierToken, resolveIdentifier} from './identifiers';
+import {Identifiers, createIdentifier, resolveIdentifier} from './identifiers';
 import {CompilerInjectable} from './injectable';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';

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

@@ -9,7 +9,7 @@
 import {NgModule, Type} from '@angular/core';
 
 import {ListWrapper} from './facade/collection';
-import {isPresent, stringify} from './facade/lang';
+import {stringify} from './facade/lang';
 import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 
@@ -30,7 +30,7 @@ export class NgModuleResolver {
     const ngModuleMeta: NgModule =
         ListWrapper.findLast(this._reflector.annotations(type), _isNgModuleMetadata);
 
-    if (isPresent(ngModuleMeta)) {
+    if (ngModuleMeta) {
       return ngModuleMeta;
     } else {
       if (throwIfNotFound) {

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

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

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

@@ -7,7 +7,6 @@
  */
 
 
-import {CompileIdentifierMetadata} from '../compile_metadata';
 import {ValueTransformer, visitValue} from '../util';
 
 import * as o from './output_ast';

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

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

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

@@ -9,7 +9,7 @@
 
 import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata, tokenName, tokenReference} from './compile_metadata';
 import {isBlank, isPresent} from './facade/lang';
-import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
+import {Identifiers, resolveIdentifier} from './identifiers';
 import {ParseError, ParseSourceSpan} from './parse_util';
 import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, ReferenceAst} from './template_parser/template_ast';
 
@@ -114,7 +114,7 @@ export class ProviderElementContext {
     let queries: CompileQueryMetadata[];
     while (currentEl !== null) {
       queries = currentEl._contentQueries.get(tokenReference(token));
-      if (isPresent(queries)) {
+      if (queries) {
         result.push(...queries.filter((query) => query.descendants || distance <= 1));
       }
       if (currentEl._directiveAsts.length > 0) {
@@ -123,7 +123,7 @@ export class ProviderElementContext {
       currentEl = currentEl._parent;
     }
     queries = this.viewContext.viewQueries.get(tokenReference(token));
-    if (isPresent(queries)) {
+    if (queries) {
       result.push(...queries);
     }
     return result;
@@ -143,7 +143,7 @@ export class ProviderElementContext {
       return null;
     }
     let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
-    if (isPresent(transformedProviderAst)) {
+    if (transformedProviderAst) {
       return transformedProviderAst;
     }
     if (isPresent(this._seenProviders.get(tokenReference(token)))) {
@@ -165,11 +165,11 @@ export class ProviderElementContext {
           transformedUseExisting = null;
           transformedUseValue = existingDiDep.value;
         }
-      } else if (isPresent(provider.useFactory)) {
+      } else if (provider.useFactory) {
         const deps = provider.deps || provider.useFactory.diDeps;
         transformedDeps =
             deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));
-      } else if (isPresent(provider.useClass)) {
+      } else if (provider.useClass) {
         const deps = provider.deps || provider.useClass.diDeps;
         transformedDeps =
             deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager));
@@ -235,7 +235,7 @@ export class ProviderElementContext {
       }
     } else {
       // check parent elements
-      while (!result && isPresent(currElement._parent)) {
+      while (!result && currElement._parent) {
         const prevElement = currElement;
         currElement = currElement._parent;
         if (prevElement._isViewRoot) {
@@ -301,7 +301,7 @@ export class NgModuleProviderAnalyzer {
       return null;
     }
     let transformedProviderAst = this._transformedProviders.get(tokenReference(token));
-    if (isPresent(transformedProviderAst)) {
+    if (transformedProviderAst) {
       return transformedProviderAst;
     }
     if (isPresent(this._seenProviders.get(tokenReference(token)))) {
@@ -324,11 +324,11 @@ export class NgModuleProviderAnalyzer {
           transformedUseExisting = null;
           transformedUseValue = existingDiDep.value;
         }
-      } else if (isPresent(provider.useFactory)) {
+      } else if (provider.useFactory) {
         const deps = provider.deps || provider.useFactory.diDeps;
         transformedDeps =
             deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));
-      } else if (isPresent(provider.useClass)) {
+      } else if (provider.useClass) {
         const deps = provider.deps || provider.useClass.diDeps;
         transformedDeps =
             deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));
@@ -454,7 +454,7 @@ function _resolveProviders(
 
 function _getViewQueries(component: CompileDirectiveMetadata): Map<any, CompileQueryMetadata[]> {
   const viewQueries = new Map<any, CompileQueryMetadata[]>();
-  if (isPresent(component.viewQueries)) {
+  if (component.viewQueries) {
     component.viewQueries.forEach((query) => _addQueryToTokenMap(viewQueries, query));
   }
   return viewQueries;
@@ -464,7 +464,7 @@ function _getContentQueries(directives: CompileDirectiveSummary[]):
     Map<any, CompileQueryMetadata[]> {
   const contentQueries = new Map<any, CompileQueryMetadata[]>();
   directives.forEach(directive => {
-    if (isPresent(directive.queries)) {
+    if (directive.queries) {
       directive.queries.forEach((query) => _addQueryToTokenMap(contentQueries, query));
     }
   });

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

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

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

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

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

@@ -11,7 +11,6 @@ import {SecurityContext} from '@angular/core';
 import {CompileDirectiveSummary, CompilePipeSummary} from '../compile_metadata';
 import {ASTWithSource, BindingPipe, EmptyExpr, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
 import {Parser} from '../expression_parser/parser';
-import {isPresent} from '../facade/lang';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {mergeNsAndName} from '../ml_parser/tags';
 import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
@@ -111,14 +110,14 @@ export class BindingParser {
   }
 
   parseInlineTemplateBinding(
-      name: string, prefixToken: string, value: string, sourceSpan: ParseSourceSpan,
+      prefixToken: string, value: string, sourceSpan: ParseSourceSpan,
       targetMatchableAttrs: string[][], targetProps: BoundProperty[], targetVars: VariableAst[]) {
     const bindings = this._parseTemplateBindings(prefixToken, value, sourceSpan);
     for (let i = 0; i < bindings.length; i++) {
       const binding = bindings[i];
       if (binding.keyIsVar) {
         targetVars.push(new VariableAst(binding.key, binding.name, sourceSpan));
-      } else if (isPresent(binding.expression)) {
+      } else if (binding.expression) {
         this._parsePropertyAst(
             binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps);
       } else {
@@ -136,7 +135,7 @@ export class BindingParser {
       const bindingsResult = this._exprParser.parseTemplateBindings(prefixToken, value, sourceInfo);
       this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);
       bindingsResult.templateBindings.forEach((binding) => {
-        if (isPresent(binding.expression)) {
+        if (binding.expression) {
           this._checkPipes(binding.expression, sourceSpan);
         }
       });
@@ -193,7 +192,7 @@ export class BindingParser {
       name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
       targetProps: BoundProperty[]): boolean {
     const expr = this.parseInterpolation(value, sourceSpan);
-    if (isPresent(expr)) {
+    if (expr) {
       this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);
       return true;
     }
@@ -374,7 +373,7 @@ export class BindingParser {
   }
 
   private _checkPipes(ast: ASTWithSource, sourceSpan: ParseSourceSpan) {
-    if (isPresent(ast)) {
+    if (ast) {
       const collector = new PipeCollector();
       ast.visit(collector);
       collector.pipes.forEach((ast, pipeName) => {

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

@@ -149,7 +149,7 @@ export class TemplateParser {
       return new TemplateParseResult(result, errors);
     }
 
-    if (isPresent(this.transforms)) {
+    if (this.transforms) {
       this.transforms.forEach(
           (transform: TemplateAstVisitor) => { result = templateVisitAll(transform, result); });
     }
@@ -218,7 +218,7 @@ class TemplateParseVisitor implements html.Visitor {
   visitText(text: html.Text, parent: ElementContext): any {
     const ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
     const expr = this._bindingParser.parseInterpolation(text.value, text.sourceSpan);
-    if (isPresent(expr)) {
+    if (expr) {
       return new BoundTextAst(expr, ngContentIndex, text.sourceSpan);
     } else {
       return new TextAst(text.value, ngContentIndex, text.sourceSpan);
@@ -248,14 +248,14 @@ class TemplateParseVisitor implements html.Visitor {
       return null;
     }
 
-    const matchableAttrs: string[][] = [];
+    const matchableAttrs: [string, string][] = [];
     const elementOrDirectiveProps: BoundProperty[] = [];
     const elementOrDirectiveRefs: ElementOrDirectiveRef[] = [];
     const elementVars: VariableAst[] = [];
     const events: BoundEventAst[] = [];
 
     const templateElementOrDirectiveProps: BoundProperty[] = [];
-    const templateMatchableAttrs: string[][] = [];
+    const templateMatchableAttrs: [string, string][] = [];
     const templateElementVars: VariableAst[] = [];
 
     let hasInlineTemplates = false;
@@ -268,14 +268,17 @@ class TemplateParseVisitor implements html.Visitor {
           isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events,
           elementOrDirectiveRefs, elementVars);
 
-      let templateBindingsSource: string|undefined = undefined;
-      let prefixToken: string|undefined = undefined;
-      if (this._normalizeAttributeName(attr.name) == TEMPLATE_ATTR) {
+      let templateBindingsSource: string|undefined;
+      let prefixToken: string|undefined;
+      let normalizedName = this._normalizeAttributeName(attr.name);
+
+      if (normalizedName == TEMPLATE_ATTR) {
         templateBindingsSource = attr.value;
-      } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
+      } else if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) {
         templateBindingsSource = attr.value;
-        prefixToken = attr.name.substring(TEMPLATE_ATTR_PREFIX.length);  // remove the star
+        prefixToken = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length) + ':';
       }
+
       const hasTemplateBinding = isPresent(templateBindingsSource);
       if (hasTemplateBinding) {
         if (hasInlineTemplates) {
@@ -285,7 +288,7 @@ class TemplateParseVisitor implements html.Visitor {
         }
         hasInlineTemplates = true;
         this._bindingParser.parseInlineTemplateBinding(
-            attr.name, prefixToken, templateBindingsSource, attr.sourceSpan, templateMatchableAttrs,
+            prefixToken, templateBindingsSource, attr.sourceSpan, templateMatchableAttrs,
             templateElementOrDirectiveProps, templateElementVars);
       }
 
@@ -306,9 +309,11 @@ class TemplateParseVisitor implements html.Visitor {
     const elementProps: BoundElementPropertyAst[] =
         this._createElementPropertyAsts(element.name, elementOrDirectiveProps, directiveAsts);
     const isViewRoot = parent.isTemplateElement || hasInlineTemplates;
+
     const providerContext = new ProviderElementContext(
         this.providerViewContext, parent.providerContext, isViewRoot, directiveAsts, attrs,
         references, element.sourceSpan);
+
     const children = html.visitAll(
         preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children,
         ElementContext.create(
@@ -541,10 +546,12 @@ class TemplateParseVisitor implements html.Visitor {
       elementSourceSpan: ParseSourceSpan, targetReferences: ReferenceAst[]): DirectiveAst[] {
     const matchedReferences = new Set<string>();
     let component: CompileDirectiveSummary = null;
+
     const directiveAsts = directives.map((directive) => {
       const sourceSpan = new ParseSourceSpan(
           elementSourceSpan.start, elementSourceSpan.end,
           `Directive ${identifierName(directive.type)}`);
+
       if (directive.isComponent) {
         component = directive;
       }
@@ -567,6 +574,7 @@ class TemplateParseVisitor implements html.Visitor {
       return new DirectiveAst(
           directive, directiveProperties, hostProperties, hostEvents, sourceSpan);
     });
+
     elementOrDirectiveRefs.forEach((elOrDirRef) => {
       if (elOrDirRef.value.length > 0) {
         if (!matchedReferences.has(elOrDirRef.name)) {
@@ -581,7 +589,7 @@ class TemplateParseVisitor implements html.Visitor {
         }
         targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
       }
-    });  // fix syntax highlighting issue: `
+    });
     return directiveAsts;
   }
 
@@ -742,7 +750,7 @@ class NonBindableVisitor implements html.Visitor {
       return null;
     }
 
-    const attrNameAndValues = ast.attrs.map(attrAst => [attrAst.name, attrAst.value]);
+    const attrNameAndValues = ast.attrs.map((attr): [string, string] => [attr.name, attr.value]);
     const selector = createElementCssSelector(ast.name, attrNameAndValues);
     const ngContentIndex = parent.findNgContentIndex(selector);
     const children = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
@@ -811,16 +819,16 @@ class ElementContext {
 }
 
 export function createElementCssSelector(
-    elementName: string, matchableAttrs: string[][]): CssSelector {
+    elementName: string, attributes: [string, string][]): CssSelector {
   const cssSelector = new CssSelector();
   const elNameNoNs = splitNsName(elementName)[1];
 
   cssSelector.setElement(elNameNoNs);
 
-  for (let i = 0; i < matchableAttrs.length; i++) {
-    const attrName = matchableAttrs[i][0];
+  for (let i = 0; i < attributes.length; i++) {
+    const attrName = attributes[i][0];
     const attrNameNoNs = splitNsName(attrName)[1];
-    const attrValue = matchableAttrs[i][1];
+    const attrValue = attributes[i][1];
 
     cssSelector.addAttribute(attrNameNoNs, attrValue);
     if (attrName.toLowerCase() == CLASS_ATTR) {

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

@@ -26,7 +26,7 @@ export function createOfflineCompileUrlResolver(): UrlResolver {
 /**
  * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
  */
-export var DEFAULT_PACKAGE_URL_PROVIDER = {
+export const DEFAULT_PACKAGE_URL_PROVIDER = {
   provide: PACKAGE_ROOT_URL,
   useValue: '/'
 };

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

@@ -19,7 +19,7 @@ import {ProviderAst, ProviderAstType, ReferenceAst, TemplateAst} from '../templa
 import {CompileMethod} from './compile_method';
 import {CompileQuery, addQueryToTokenMap, createQueryList} from './compile_query';
 import {CompileView, CompileViewRootNode} from './compile_view';
-import {InjectMethodVars, ViewProperties} from './constants';
+import {InjectMethodVars} from './constants';
 import {ComponentFactoryDependency, DirectiveWrapperDependency} from './deps';
 import {getPropertyInView, injectFromViewParentInjector} from './util';
 
@@ -195,7 +195,7 @@ export class CompileElement extends CompileNode {
       const propName =
           `_${tokenName(resolvedProvider.token)}_${this.nodeIndex}_${this.instances.size}`;
       const instance = createProviderProperty(
-          propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider,
+          propName, providerValueExpressions, resolvedProvider.multiProvider,
           resolvedProvider.eager, this);
       if (isDirectiveWrapper) {
         this.directiveWrapperInstance.set(tokenReference(resolvedProvider.token), instance);
@@ -211,12 +211,7 @@ export class CompileElement extends CompileNode {
       const directiveInstance = this.instances.get(tokenReference(identifierToken(directive.type)));
       directive.queries.forEach((queryMeta) => { this._addQuery(queryMeta, directiveInstance); });
     }
-    const queriesWithReads: _QueryWithRead[] = [];
-    Array.from(this._resolvedProviders.values()).forEach((resolvedProvider) => {
-      const queriesForProvider = this._getQueriesFor(resolvedProvider.token);
-      queriesWithReads.push(
-          ...queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
-    });
+
     Object.keys(this.referenceTokens).forEach(varName => {
       const token = this.referenceTokens[varName];
       let varValue: o.Expression;
@@ -226,27 +221,6 @@ export class CompileElement extends CompileNode {
         varValue = this.renderNode;
       }
       this.view.locals.set(varName, varValue);
-      const varToken = {value: varName};
-      queriesWithReads.push(
-          ...this._getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
-    });
-    queriesWithReads.forEach((queryWithRead) => {
-      let value: o.Expression;
-      if (isPresent(queryWithRead.read.identifier)) {
-        // query for an identifier
-        value = this.instances.get(tokenReference(queryWithRead.read));
-      } else {
-        // query for a reference
-        const token = this.referenceTokens[queryWithRead.read.value];
-        if (isPresent(token)) {
-          value = this.instances.get(tokenReference(token));
-        } else {
-          value = this.elementRef;
-        }
-      }
-      if (isPresent(value)) {
-        queryWithRead.query.addValue(value, this.view);
-      }
     });
   }
 
@@ -265,12 +239,14 @@ export class CompileElement extends CompileNode {
       this.view.injectorGetMethod.addStmt(createInjectInternalCondition(
           this.nodeIndex, providerChildNodeCount, resolvedProvider, providerExpr));
     });
+  }
 
+  finish() {
     Array.from(this._queries.values())
         .forEach(
             queries => queries.forEach(
-                q =>
-                    q.afterChildren(this.view.createMethod, this.view.updateContentQueriesMethod)));
+                q => q.generateStatements(
+                    this.view.createMethod, this.view.updateContentQueriesMethod)));
   }
 
   addContentNode(ngContentIndex: number, nodeExpr: CompileViewRootNode) {
@@ -283,12 +259,11 @@ export class CompileElement extends CompileNode {
         null;
   }
 
-  getProviderTokens(): o.Expression[] {
-    return Array.from(this._resolvedProviders.values())
-        .map((resolvedProvider) => createDiTokenExpression(resolvedProvider.token));
+  getProviderTokens(): CompileTokenMetadata[] {
+    return Array.from(this._resolvedProviders.values()).map(provider => provider.token);
   }
 
-  private _getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
+  getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
     const result: CompileQuery[] = [];
     let currentEl: CompileElement = this;
     let distance = 0;
@@ -314,7 +289,7 @@ export class CompileElement extends CompileNode {
       CompileQuery {
     const propName =
         `_query_${tokenName(queryMeta.selectors[0])}_${this.nodeIndex}_${this._queryCount++}`;
-    const queryList = createQueryList(queryMeta, directiveInstance, propName, this.view);
+    const queryList = createQueryList(propName, this.view);
     const query = new CompileQuery(queryMeta, queryList, directiveInstance, this.view);
     addQueryToTokenMap(this._queries, query);
     return query;
@@ -394,8 +369,8 @@ function createInjectInternalCondition(
 }
 
 function createProviderProperty(
-    propName: string, provider: ProviderAst, providerValueExpressions: o.Expression[],
-    isMulti: boolean, isEager: boolean, compileElement: CompileElement): o.Expression {
+    propName: string, providerValueExpressions: o.Expression[], isMulti: boolean, isEager: boolean,
+    compileElement: CompileElement): o.Expression {
   const view = compileElement.view;
   let resolvedProviderValueExpr: o.Expression;
   let type: o.Type;
@@ -426,10 +401,3 @@ function createProviderProperty(
   }
   return o.THIS_EXPR.prop(propName);
 }
-
-class _QueryWithRead {
-  public read: CompileTokenMetadata;
-  constructor(public query: CompileQuery, match: CompileTokenMetadata) {
-    this.read = query.meta.read || match;
-  }
-}

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

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {isPresent} from '../facade/lang';
 import * as o from '../output/output_ast';
 import {TemplateAst} from '../template_parser/template_ast';
 
@@ -34,7 +33,7 @@ export class CompileMethod {
     if (this._newState.nodeIndex !== this._currState.nodeIndex ||
         this._newState.sourceAst !== this._currState.sourceAst) {
       const expr = this._updateDebugContext(this._newState);
-      if (isPresent(expr)) {
+      if (expr) {
         this._bodyStatements.push(expr.toStmt());
       }
     }
@@ -43,13 +42,12 @@ export class CompileMethod {
   private _updateDebugContext(newState: _DebugState): o.Expression {
     this._currState = this._newState = newState;
     if (this._debugEnabled) {
-      const sourceLocation =
-          isPresent(newState.sourceAst) ? newState.sourceAst.sourceSpan.start : null;
+      const sourceLocation = newState.sourceAst ? newState.sourceAst.sourceSpan.start : null;
 
       return o.THIS_EXPR.callMethod('debug', [
         o.literal(newState.nodeIndex),
-        isPresent(sourceLocation) ? o.literal(sourceLocation.line) : o.NULL_EXPR,
-        isPresent(sourceLocation) ? o.literal(sourceLocation.col) : o.NULL_EXPR
+        sourceLocation ? o.literal(sourceLocation.line) : o.NULL_EXPR,
+        sourceLocation ? o.literal(sourceLocation.col) : o.NULL_EXPR
       ]);
     } else {
       return null;

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

@@ -8,7 +8,6 @@
 
 import {CompileQueryMetadata, tokenReference} from '../compile_metadata';
 import {ListWrapper} from '../facade/collection';
-import {isPresent} from '../facade/lang';
 import {Identifiers, createIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 
@@ -33,7 +32,7 @@ export class CompileQuery {
   addValue(value: o.Expression, view: CompileView) {
     let currentView = view;
     const elPath: CompileElement[] = [];
-    while (isPresent(currentView) && currentView !== this.view) {
+    while (currentView && currentView !== this.view) {
       const parentEl = currentView.declarationElement;
       elPath.unshift(parentEl);
       currentView = parentEl.view;
@@ -64,10 +63,10 @@ export class CompileQuery {
     return !this._values.values.some(value => value instanceof ViewQueryValues);
   }
 
-  afterChildren(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
+  generateStatements(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
     const values = createQueryValues(this._values);
     const updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
-    if (isPresent(this.ownerDirectiveExpression)) {
+    if (this.ownerDirectiveExpression) {
       const valueExpr = this.meta.first ? this.queryList.prop('first') : this.queryList;
       updateStmts.push(
           this.ownerDirectiveExpression.prop(this.meta.propertyName).set(valueExpr).toStmt());
@@ -110,9 +109,7 @@ function mapNestedViews(
   ]);
 }
 
-export function createQueryList(
-    query: CompileQueryMetadata, directiveInstance: o.Expression, propertyName: string,
-    compileView: CompileView): o.Expression {
+export function createQueryList(propertyName: string, compileView: CompileView): o.Expression {
   compileView.fields.push(new o.ClassField(
       propertyName, o.importType(createIdentifier(Identifiers.QueryList), [o.DYNAMIC_TYPE])));
   const expr = o.THIS_EXPR.prop(propertyName);

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

@@ -12,7 +12,6 @@ import {EventHandlerVars, NameResolver} from '../compiler_util/expression_conver
 import {createPureProxy} from '../compiler_util/identifier_util';
 import {CompilerConfig} from '../config';
 import {isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ViewType} from '../private_import_core';
 
@@ -119,7 +118,7 @@ export class CompileView implements NameResolver {
       const directiveInstance = o.THIS_EXPR.prop('context');
       this.component.viewQueries.forEach((queryMeta, queryIndex) => {
         const propName = `_viewQuery_${tokenName(queryMeta.selectors[0])}_${queryIndex}`;
-        const queryList = createQueryList(queryMeta, directiveInstance, propName, this);
+        const queryList = createQueryList(propName, this);
         const query = new CompileQuery(queryMeta, queryList, directiveInstance, this);
         addQueryToTokenMap(viewQueries, query);
       });
@@ -154,11 +153,11 @@ export class CompileView implements NameResolver {
     }
   }
 
-  afterNodes() {
+  finish() {
     Array.from(this.viewQueries.values())
         .forEach(
             queries => queries.forEach(
-                q => q.afterChildren(this.createMethod, this.updateViewQueriesMethod)));
+                q => q.generateStatements(this.createMethod, this.updateViewQueriesMethod)));
   }
 }
 

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

@@ -11,7 +11,7 @@ import {ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';
 import {createEnumExpression} from '../compiler_util/identifier_util';
 import {Identifiers} from '../identifiers';
 import * as o from '../output/output_ast';
-import {ChangeDetectorStatus, ViewType} from '../private_import_core';
+import {ViewType} from '../private_import_core';
 
 export class ViewTypeEnum {
   static fromValue(value: ViewType): o.Expression {
@@ -25,12 +25,6 @@ export class ViewEncapsulationEnum {
   }
 }
 
-export class ChangeDetectionStrategyEnum {
-  static fromValue(value: ChangeDetectionStrategy): o.Expression {
-    return createEnumExpression(Identifiers.ChangeDetectionStrategy, value);
-  }
-}
-
 export class ChangeDetectorStatusEnum {
   static fromValue(value: ChangeDetectorStatusEnum): o.Expression {
     return createEnumExpression(Identifiers.ChangeDetectorStatus, value);

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

@@ -15,7 +15,6 @@ import {BoundEventAst, DirectiveAst} from '../template_parser/template_ast';
 
 import {CompileElement} from './compile_element';
 import {CompileMethod} from './compile_method';
-import {ViewProperties} from './constants';
 import {getHandleEventMethodName} from './util';
 
 export function bindOutputs(
@@ -133,4 +132,4 @@ type EventSummary = {
   name: string,
   target: string,
   phase: string
-}
+};

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

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

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

@@ -9,8 +9,6 @@
 
 import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, CompileTokenMetadata, identifierName} from '../compile_metadata';
 import {createDiTokenExpression} from '../compiler_util/identifier_util';
-import {isPresent} from '../facade/lang';
-import {Identifiers, createIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ViewType} from '../private_import_core';
 
@@ -23,7 +21,7 @@ export function getPropertyInView(
   } else {
     let viewProp: o.Expression = o.THIS_EXPR;
     let currView: CompileView = callingView;
-    while (currView !== definedView && isPresent(currView.declarationElement.view)) {
+    while (currView !== definedView && currView.declarationElement.view) {
       currView = currView.declarationElement.view;
       viewProp = viewProp.prop('parentView');
     }

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

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

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

@@ -15,7 +15,6 @@ import {isPresent} from '../facade/lang';
 import {Identifiers, createIdentifier, identifierToken} from '../identifiers';
 import {createClassStmt} from '../output/class_builder';
 import * as o from '../output/output_ast';
-import {ParseSourceSpan} from '../parse_util';
 import {ChangeDetectorStatus, ViewType, isDefaultChangeDetectionStrategy} from '../private_import_core';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from '../template_parser/template_ast';
 
@@ -48,13 +47,16 @@ export function buildView(
 }
 
 export function finishView(view: CompileView, targetStatements: o.Statement[]) {
-  view.afterNodes();
-  createViewTopLevelStmts(view, targetStatements);
   view.nodes.forEach((node) => {
-    if (node instanceof CompileElement && node.hasEmbeddedView) {
-      finishView(node.embeddedView, targetStatements);
+    if (node instanceof CompileElement) {
+      node.finish();
+      if (node.hasEmbeddedView) {
+        finishView(node.embeddedView, targetStatements);
+      }
     }
   });
+  view.finish();
+  createViewTopLevelStmts(view, targetStatements);
 }
 
 class ViewBuilderVisitor implements TemplateAstVisitor {
@@ -418,7 +420,9 @@ function createStaticNodeDebugInfo(node: CompileNode): o.Expression {
   let componentToken: o.Expression = o.NULL_EXPR;
   const varTokenEntries: any[] = [];
   if (isPresent(compileElement)) {
-    providerTokens = compileElement.getProviderTokens();
+    providerTokens =
+        compileElement.getProviderTokens().map((token) => createDiTokenExpression(token));
+
     if (isPresent(compileElement.component)) {
       componentToken = createDiTokenExpression(identifierToken(compileElement.component.type));
     }
@@ -690,7 +694,6 @@ function generateCreateEmbeddedViewsMethod(view: CompileView): o.ClassMethod {
   view.nodes.forEach((node) => {
     if (node instanceof CompileElement) {
       if (node.embeddedView) {
-        const parentNodeIndex = node.isRootElement() ? null : node.parent.nodeIndex;
         stmts.push(new o.IfStmt(
             nodeIndexVar.equals(o.literal(node.nodeIndex)),
             [new o.ReturnStatement(node.embeddedView.classExpr.instantiate([

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

@@ -449,6 +449,40 @@ describe('StaticReflector', () => {
     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) {}

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

@@ -210,5 +210,56 @@ const XMB = `
     <ph name="START_TAG_DIV_1"><ex>&lt;div&gt;</ex></ph><ph name="ICU"/><ph name="CLOSE_TAG_DIV"><ex>&lt;/div&gt;</ex></ph>
 </msg>
   <msg id="1491627405349178954">it <ph name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>should<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph> work</msg>
-</messagebundle>
+</messagebundle>`;
+
+const HTML = `
+<div>
+    <h1 i18n>i18n attribute on tags</h1>
+    
+    <div id="i18n-1"><p i18n>nested</p></div>
+    
+    <div id="i18n-2"><p i18n="different meaning|">nested</p></div>
+    
+    <div id="i18n-3"><p i18n><i>with placeholders</i></p></div>
+    <div id="i18n-3b"><p i18n><i class="preserved-on-placeholders">with placeholders</i></p></div>
+    
+    <div>
+        <p id="i18n-4" i18n-title title="on not translatable node"></p>
+        <p id="i18n-5" i18n i18n-title title="on translatable node"></p>
+        <p id="i18n-6" i18n-title title></p>
+    </div>
+    
+    <!-- no ph below because the ICU node is the only child of the div, i.e. no text nodes --> 
+    <div i18n id="i18n-7">{count, plural, =0 {zero} =1 {one} =2 {two} other {<b>many</b>}}</div>
+    
+    <div i18n id="i18n-8">
+        {sex, select, m {male} f {female}}
+    </div>
+    <div i18n id="i18n-8b">
+        {sexB, select, m {male} f {female}}
+    </div>
+    
+    <div i18n id="i18n-9">{{ "count = " + count }}</div>
+    <div i18n id="i18n-10">sex = {{ sex }}</div>
+    <div i18n id="i18n-11">{{ "custom name" //i18n(ph="CUSTOM_NAME") }}</div>    
+</div>
+
+<!-- i18n -->
+    <h1 id="i18n-12" >Markers in html comments</h1>   
+    <div id="i18n-13" i18n-title title="in a translatable section"></div>
+    <div id="i18n-14">{count, plural, =0 {zero} =1 {one} =2 {two} other {<b>many</b>}}</div>
+<!-- /i18n -->
+
+<div id="i18n-15"><ng-container i18n>it <b>should</b> work</ng-container></div>
+
+<!-- make sure that ICU messages are not treated as text nodes -->
+<div i18n="desc">{
+    response.getItemsList().length,
+    plural,
+    =0 {Found no results}
+    =1 {Found one result}
+    other {Found {{response.getItemsList().length}} results}
+}</div>
+
+<div i18n id="i18n-18">foo<a i18n-title title="in a translatable section">bar</a></div>
 `;

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

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Component, Directive, Input} from '@angular/core';
+import {ComponentFixture, TestBed, async} from '@angular/core/testing';
+import {By} from '@angular/platform-browser/src/dom/debug/by';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('integration tests', () => {
+    let fixture: ComponentFixture<TestComponent>;
+
+
+    describe('directives', () => {
+      it('should support dotted selectors', async(() => {
+           @Directive({selector: '[dot.name]'})
+           class MyDir {
+             @Input('dot.name') value: string;
+           }
+
+           TestBed.configureTestingModule({
+             declarations: [
+               MyDir,
+               TestComponent,
+             ],
+           });
+
+           const template = `<div [dot.name]="'foo'"></div>`;
+           fixture = createTestComponent(template);
+           fixture.detectChanges();
+           const myDir = fixture.debugElement.query(By.directive(MyDir)).injector.get(MyDir);
+           expect(myDir.value).toEqual('foo');
+         }));
+    });
+
+  });
+}
+
+@Component({selector: 'test-cmp', template: ''})
+class TestComponent {
+}
+
+function createTestComponent(template: string): ComponentFixture<TestComponent> {
+  return TestBed.overrideComponent(TestComponent, {set: {template: template}})
+      .createComponent(TestComponent);
+}

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

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

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

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

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

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

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

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

modules/@angular/compiler/test/template_parser/template_parser_spec.ts

@@ -623,6 +623,23 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
              ]);
            });
 
+        it('should parse directive dotted properties', () => {
+          const dirA =
+              CompileDirectiveMetadata
+                  .create({
+                    selector: '[dot.name]',
+                    type: createTypeMeta({reference: {filePath: someModuleUrl, name: 'DirA'}}),
+                    inputs: ['localName: dot.name'],
+                  })
+                  .toSummary();
+
+          expect(humanizeTplAst(parse('<div [dot.name]="expr"></div>', [dirA]))).toEqual([
+            [ElementAst, 'div'],
+            [DirectiveAst, dirA],
+            [BoundDirectivePropertyAst, 'localName', 'expr'],
+          ]);
+        });
+
         it('should locate directives in property bindings', () => {
           const dirA =
               CompileDirectiveMetadata
@@ -1244,8 +1261,15 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
         });
 
         it('should parse variables via let ...', () => {
-          expect(humanizeTplAst(parse('<div *ngIf="let a=b">', [
-          ]))).toEqual([[EmbeddedTemplateAst], [VariableAst, 'a', 'b'], [ElementAst, 'div']]);
+          const targetAst = [
+            [EmbeddedTemplateAst],
+            [VariableAst, 'a', 'b'],
+            [ElementAst, 'div'],
+          ];
+
+          expect(humanizeTplAst(parse('<div *ngIf="let a=b">', []))).toEqual(targetAst);
+
+          expect(humanizeTplAst(parse('<div data-*ngIf="let a=b">', []))).toEqual(targetAst);
         });
 
         describe('directives', () => {
@@ -1299,17 +1323,30 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
 
         });
 
+
         it('should work with *... and use the attribute name as property binding name', () => {
           expect(humanizeTplAst(parse('<div *ngIf="test">', [ngIf]))).toEqual([
-            [EmbeddedTemplateAst], [DirectiveAst, ngIf],
-            [BoundDirectivePropertyAst, 'ngIf', 'test'], [ElementAst, 'div']
+            [EmbeddedTemplateAst],
+            [DirectiveAst, ngIf],
+            [BoundDirectivePropertyAst, 'ngIf', 'test'],
+            [ElementAst, 'div'],
+          ]);
+
+          // https://github.com/angular/angular/issues/13800
+          expect(humanizeTplAst(parse('<div *ngIf="-1">', [ngIf]))).toEqual([
+            [EmbeddedTemplateAst],
+            [DirectiveAst, ngIf],
+            [BoundDirectivePropertyAst, 'ngIf', '0 - 1'],
+            [ElementAst, 'div'],
           ]);
         });
 
         it('should work with *... and empty value', () => {
           expect(humanizeTplAst(parse('<div *ngIf>', [ngIf]))).toEqual([
-            [EmbeddedTemplateAst], [DirectiveAst, ngIf],
-            [BoundDirectivePropertyAst, 'ngIf', 'null'], [ElementAst, 'div']
+            [EmbeddedTemplateAst],
+            [DirectiveAst, ngIf],
+            [BoundDirectivePropertyAst, 'ngIf', 'null'],
+            [ElementAst, 'div'],
           ]);
         });
       });

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

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

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

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

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

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

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

@@ -469,7 +469,7 @@ export class ApplicationRef_ extends ApplicationRef {
     this._loadComponent(compRef);
     if (isDevMode()) {
       this._console.log(
-          `Angular 2 is running in the development mode. Call enableProdMode() to enable the production mode.`);
+          `Angular is running in the development mode. Call enableProdMode() to enable the production mode.`);
     }
     return compRef;
   }

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

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

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

@@ -13,7 +13,6 @@ import {Type} from '../type';
 
 import {ElementRef} from './element_ref';
 import {AppView} from './view';
-import {ViewContainer} from './view_container';
 import {ViewRef} from './view_ref';
 import {ViewUtils} from './view_utils';
 
@@ -86,11 +85,6 @@ export class ComponentRef_<C> extends ComponentRef<C> {
   onDestroy(callback: Function): void { this.hostView.onDestroy(callback); }
 }
 
-/**
- * @experimental
- */
-const EMPTY_CONTEXT = new Object();
-
 /**
  * @stable
  */

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

@@ -19,7 +19,8 @@ import {ComponentFactory} from './component_factory';
  */
 export class NoComponentFactoryError extends BaseError {
   constructor(public component: Function) {
-    super(`No component factory found for ${stringify(component)}`);
+    super(
+        `No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);
   }
 }
 

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

@@ -8,7 +8,6 @@
 
 import {ElementRef} from './element_ref';
 import {AppView} from './view';
-import {ViewContainer} from './view_container';
 import {EmbeddedViewRef} from './view_ref';
 
 

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

@@ -11,7 +11,7 @@ import {ChangeDetectorRef, ChangeDetectorStatus} from '../change_detection/chang
 import {Injector, THROW_IF_NOT_FOUND} from '../di/injector';
 import {isPresent} from '../facade/lang';
 import {WtfScopeFn, wtfCreateScope, wtfLeave} from '../profile/profile';
-import {DirectRenderer, RenderComponentType, RenderDebugInfo, Renderer} from '../render/api';
+import {DirectRenderer, RenderComponentType, Renderer} from '../render/api';
 
 import {AnimationViewContext} from './animation_view_context';
 import {ComponentRef} from './component_factory';

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

@@ -7,10 +7,8 @@
  */
 
 import {Injector} from '../di/injector';
-import {isPresent} from '../facade/lang';
 
 import {ElementRef} from './element_ref';
-import {QueryList} from './query_list';
 import {AppView} from './view';
 import {ViewContainerRef_} from './view_container_ref';
 import {ViewType} from './view_type';

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

@@ -15,7 +15,6 @@ import {ViewEncapsulation} from '../metadata/view';
 import {RenderComponentType, RenderDebugInfo, Renderer, RootRenderer} from '../render/api';
 import {Sanitizer} from '../security';
 import {VERSION} from '../version';
-import {NgZone} from '../zone/ng_zone';
 
 import {ExpressionChangedAfterItHasBeenCheckedError} from './errors';
 import {AppView} from './view';
@@ -23,7 +22,6 @@ import {AppView} from './view';
 @Injectable()
 export class ViewUtils {
   sanitizer: Sanitizer;
-  private _nextCompTypeId: number = 0;
 
   constructor(
       private _renderer: RootRenderer, sanitizer: Sanitizer,

modules/@angular/core/src/metadata/di.ts

@@ -225,7 +225,33 @@ export const ContentChildren: ContentChildrenDecorator =
  */
 export interface ContentChildDecorator {
   /**
-   * @docsNotRequired
+   * @whatItDoes Configures a content query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ContentChild to get the first element or the directive matching the selector from
+   * the content DOM. If the content DOM changes, and a new child matches the selector,
+   * the property will be updated.
+   *
+   * Content queries are set before the `ngAfterContentInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **read** - read a different token from the queried element.
+   *
+   * Let's look at an example:
+   *
+   * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
    */
   (selector: Type<any>|Function|string, {read}?: {read?: any}): any;
   new (selector: Type<any>|Function|string, {read}?: {read?: any}): ContentChild;
@@ -241,30 +267,7 @@ export interface ContentChildDecorator {
 export type ContentChild = Query;
 
 /**
- * @whatItDoes Configures a content query.
- *
- * @howToUse
- *
- * {@example core/di/ts/contentChild/content_child_howto.ts region='HowTo'}
- *
- * @description
- *
- * You can use ContentChild to get the first element or the directive matching the selector from the
- * content DOM. If the content DOM changes, and a new child matches the selector,
- * the property will be updated.
- *
- * Content queries are set before the `ngAfterContentInit` callback is called.
- *
- * **Metadata Properties**:
- *
- * * **selector** - the directive type or the name used for querying.
- * * **read** - read a different token from the queried element.
- *
- * Let's look at an example:
- *
- * {@example core/di/ts/contentChild/content_child_example.ts region='Component'}
- *
- * **npm package**: `@angular/core`
+ * ContentChild decorator and metadata.
  *
  * @stable
  * @Annotation
@@ -290,8 +293,35 @@ export const ContentChild: ContentChildDecorator = makePropDecorator(
  */
 export interface ViewChildrenDecorator {
   /**
-   * @docsNotRequired
- */ (selector: Type<any>|Function|string, {read}?: {read?: any}): any;
+   * @whatItDoes Configures a view query.
+   *
+   * @howToUse
+   *
+   * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}
+   *
+   * @description
+   *
+   * You can use ViewChildren to get the {@link QueryList} of elements or directives from the
+   * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,
+   * and the changes observable of the query list will emit a new value.
+   *
+   * View queries are set before the `ngAfterViewInit` callback is called.
+   *
+   * **Metadata Properties**:
+   *
+   * * **selector** - the directive type or the name used for querying.
+   * * **read** - read a different token from the queried elements.
+   *
+   * Let's look at an example:
+   *
+   * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}
+   *
+   * **npm package**: `@angular/core`
+   *
+   * @stable
+   * @Annotation
+   */
+  (selector: Type<any>|Function|string, {read}?: {read?: any}): any;
   new (selector: Type<any>|Function|string, {read}?: {read?: any}): ViewChildren;
 }
 
@@ -303,30 +333,7 @@ export interface ViewChildrenDecorator {
 export type ViewChildren = Query;
 
 /**
- * @whatItDoes Configures a view query.
- *
- * @howToUse
- *
- * {@example core/di/ts/viewChildren/view_children_howto.ts region='HowTo'}
- *
- * @description
- *
- * You can use ViewChildren to get the {@link QueryList} of elements or directives from the
- * view DOM. Any time a child element is added, removed, or moved, the query list will be updated,
- * and the changes observable of the query list will emit a new value.
- *
- * View queries are set before the `ngAfterViewInit` callback is called.
- *
- * **Metadata Properties**:
- *
- * * **selector** - the directive type or the name used for querying.
- * * **read** - read a different token from the queried elements.
- *
- * Let's look at an example:
- *
- * {@example core/di/ts/viewChildren/view_children_example.ts region='Component'}
- *
- * **npm package**: `@angular/core`
+ * ViewChildren decorator and metadata.
  *
  * @stable
  * @Annotation

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

@@ -50,7 +50,7 @@ function noopScope(arg0?: any, arg1?: any): any {
  *
  * @experimental
  */
-export var wtfCreateScope: (signature: string, flags?: any) => WtfScopeFn =
+export const wtfCreateScope: (signature: string, flags?: any) => WtfScopeFn =
     wtfEnabled ? createScope : (signature: string, flags?: any) => noopScope;
 
 /**
@@ -62,7 +62,7 @@ export var wtfCreateScope: (signature: string, flags?: any) => WtfScopeFn =
  * Returns the `returnValue for easy chaining.
  * @experimental
  */
-export var wtfLeave: <T>(scope: any, returnValue?: T) => T =
+export const wtfLeave: <T>(scope: any, returnValue?: T) => T =
     wtfEnabled ? leave : (s: any, r?: any) => r;
 
 /**
@@ -78,7 +78,7 @@ export var wtfLeave: <T>(scope: any, returnValue?: T) => T =
  *     }
  * @experimental
  */
-export var wtfStartTimeRange: (rangeType: string, action: string) => any =
+export const wtfStartTimeRange: (rangeType: string, action: string) => any =
     wtfEnabled ? startTimeRange : (rangeType: string, action: string) => null;
 
 /**
@@ -87,4 +87,4 @@ export var wtfStartTimeRange: (rangeType: string, action: string) => any =
  * enabled.
  * @experimental
  */
-export var wtfEndTimeRange: (range: any) => void = wtfEnabled ? endTimeRange : (r: any) => null;
+export const wtfEndTimeRange: (range: any) => void = wtfEnabled ? endTimeRange : (r: any) => null;

modules/@angular/core/src/reflection/reflection_capabilities.ts

@@ -7,7 +7,7 @@
  */
 
 import {global, isPresent, stringify} from '../facade/lang';
-import {Type} from '../type';
+import {Type, isType} from '../type';
 
 import {PlatformReflectionCapabilities} from './platform_reflection_capabilities';
 import {GetterFn, MethodFn, SetterFn} from './types';
@@ -105,7 +105,10 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
   parameters(type: Type<any>): any[][] {
     // Note: only report metadata if we have at least one class decorator
     // to stay in sync with the static reflector.
-    const parentCtor = Object.getPrototypeOf(type.prototype).constructor;
+    if (!isType(type)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(type);
     let parameters = this._ownParameters(type, parentCtor);
     if (!parameters && parentCtor !== Object) {
       parameters = this.parameters(parentCtor);
@@ -135,7 +138,10 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
   }
 
   annotations(typeOrFunc: Type<any>): any[] {
-    const parentCtor = Object.getPrototypeOf(typeOrFunc.prototype).constructor;
+    if (!isType(typeOrFunc)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
     const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
     const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
     return parentAnnotations.concat(ownAnnotations);
@@ -170,7 +176,10 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
   }
 
   propMetadata(typeOrFunc: any): {[key: string]: any[]} {
-    const parentCtor = Object.getPrototypeOf(typeOrFunc.prototype).constructor;
+    if (!isType(typeOrFunc)) {
+      return {};
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
     const propMetadata: {[key: string]: any[]} = {};
     if (parentCtor !== Object) {
       const parentPropMetadata = this.propMetadata(parentCtor);
@@ -233,3 +242,11 @@ function convertTsickleDecoratorIntoMetadata(decoratorInvocations: any[]): any[]
     return new annotationCls(...annotationArgs);
   });
 }
+
+function getParentCtor(ctor: Function): Type<any> {
+  const parentProto = Object.getPrototypeOf(ctor.prototype);
+  const parentCtor = parentProto ? parentProto.constructor : null;
+  // Note: We always use `Object` as the null value
+  // to simplify checking later on.
+  return parentCtor || Object;
+}

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

@@ -18,5 +18,8 @@
  */
 export const Type = Function;
 
+export function isType(v: any): v is Type<any> {
+  return typeof v === 'function';
+}
 
 export interface Type<T> extends Function { new (...args: any[]): T; }

modules/@angular/core/test/animation/animation_integration_spec.ts

@@ -17,16 +17,15 @@ import {WebAnimationsDriver} from '@angular/platform-browser/src/dom/web_animati
 import {WebAnimationsPlayer} from '@angular/platform-browser/src/dom/web_animations_player';
 import {expect} from '@angular/platform-browser/testing/matchers';
 import {MockAnimationDriver} from '@angular/platform-browser/testing/mock_animation_driver';
-
-import {DomAnimatePlayer} from '../../../platform-browser/src/dom/dom_animate_player';
 import {ApplicationRef, Component, HostBinding, HostListener, NgModule, NgZone, destroyPlatform} from '../../index';
 import {DEFAULT_STATE} from '../../src/animation/animation_constants';
 import {AnimationGroupPlayer} from '../../src/animation/animation_group_player';
 import {AnimationKeyframe} from '../../src/animation/animation_keyframe';
-import {AnimationPlayer} from '../../src/animation/animation_player';
+import {AnimationPlayer, NoOpAnimationPlayer} from '../../src/animation/animation_player';
 import {AnimationStyles} from '../../src/animation/animation_styles';
 import {AnimationTransitionEvent} from '../../src/animation/animation_transition_event';
 import {AUTO_STYLE, animate, group, keyframes, sequence, state, style, transition, trigger} from '../../src/animation/metadata';
+import {Input} from '../../src/core';
 import {isPresent} from '../../src/facade/lang';
 import {TestBed, fakeAsync, flushMicrotasks} from '../../testing';
 import {MockAnimationPlayer} from '../../testing/mock_animation_player';
@@ -2244,6 +2243,56 @@ function declareTests({useJit}: {useJit: boolean}) {
        }));
   });
 
+  describe('error handling', () => {
+    if (!getDOM().supportsWebAnimation()) return;
+
+    it('should not throw an error when an animation exists within projected content that is not bound to the DOM',
+       fakeAsync(() => {
+         TestBed.configureTestingModule({
+           declarations: [DummyIfCmp, DummyLoadingCmp],
+           providers: [{provide: AnimationDriver, useClass: WebAnimationsDriver}],
+           imports: [CommonModule]
+         });
+         TestBed.overrideComponent(DummyIfCmp, {
+           set: {
+             template: `
+               <dummy-loading-cmp [exp2]="exp">
+                 <div [@myAnimation]="exp ? 'true' : 'false'" (@myAnimation.done)="callback()">world</div>
+               </dummy-loading-cmp>
+          `,
+             animations: [trigger('myAnimation', [transition(
+                                                     '* => *',
+                                                     [
+                                                       style({opacity: 0}),
+                                                       animate(1000, style({opacity: 1})),
+                                                     ])])]
+           }
+         });
+         TestBed.overrideComponent(
+             DummyLoadingCmp, {set: {template: `hello <ng-content *ngIf="exp2"></ng-content>`}});
+
+         const fixture = TestBed.createComponent(DummyIfCmp);
+         const cmp = fixture.componentInstance;
+         const container = fixture.nativeElement;
+         let animationCalls = 0;
+         cmp.callback = () => animationCalls++;
+
+         cmp.exp = false;
+         fixture.detectChanges();
+         flushMicrotasks();
+
+         expect(animationCalls).toBe(1);
+         expect(getDOM().getText(container).trim()).toEqual('hello');
+
+         cmp.exp = true;
+         fixture.detectChanges();
+         flushMicrotasks();
+
+         expect(animationCalls).toBe(2);
+         expect(getDOM().getText(container).trim()).toMatch(/hello[\s\r\n]+world/m);
+       }));
+  });
+
   describe('full animation integration tests', () => {
     if (!getDOM().supportsWebAnimation()) return;
 
@@ -2426,6 +2475,9 @@ class DummyIfCmp {
 class DummyLoadingCmp {
   exp: any = false;
   callback = () => {};
+
+  @Input('exp2')
+  exp2: any = false;
 }
 
 @Component({

modules/@angular/core/test/application_init_spec.ts

@@ -32,7 +32,7 @@ export function main() {
             {providers: [{provide: APP_INITIALIZER, multi: true, useValue: () => promise}]});
       });
 
-      it('should updat the status once all async initializers are done',
+      it('should update the status once all async initializers are done',
          async(inject([ApplicationInitStatus], (status: ApplicationInitStatus) => {
            let completerResolver = false;
            setTimeout(() => {

modules/@angular/core/test/application_module_spec.ts

@@ -14,4 +14,4 @@ export function main() {
     it('should set the default locale to "en-US"',
        inject([LOCALE_ID], (defaultLocale: string) => { expect(defaultLocale).toEqual('en-US'); }));
   });
-}
+}

modules/@angular/core/test/linker/direct_rendering_integration_spec.ts

@@ -138,7 +138,7 @@ export function main() {
       @Component({
         selector: 'child',
         template:
-            '(<template [ngTemplateOutlet]="templateRef" [ngOutletContext]="templateCtx"></template>)'
+            '(<ng-container [ngTemplateOutlet]="templateRef" [ngOutletContext]="templateCtx"></ng-container>)'
       })
       class Child {
         @Input()

modules/@angular/core/test/linker/ng_container_integration_spec.ts

@@ -23,8 +23,15 @@ function declareTests({useJit}: {useJit: boolean}) {
 
     beforeEach(() => {
       TestBed.configureCompiler({useJit: useJit});
-      TestBed.configureTestingModule(
-          {declarations: [MyComp, NeedsContentChildren, NeedsViewChildren, TextDirective, Simple]});
+      TestBed.configureTestingModule({
+        declarations: [
+          MyComp,
+          NeedsContentChildren,
+          NeedsViewChildren,
+          TextDirective,
+          Simple,
+        ],
+      });
     });
 
     it('should support the "i18n" attribute', () => {

modules/@angular/core/test/linker/query_integration_spec.ts

@@ -43,6 +43,8 @@ export function main() {
         NeedsContentChildWithRead,
         NeedsViewChildrenWithRead,
         NeedsViewChildWithRead,
+        NeedsContentChildTemplateRef,
+        NeedsContentChildTemplateRefApp,
         NeedsViewContainerWithRead,
         ManualProjecting
       ]
@@ -262,6 +264,15 @@ export function main() {
         expect(comp.textDirChild.text).toEqual('ca');
       });
 
+      it('should contain the first descendant content child templateRef', () => {
+        const template = '<needs-content-child-template-ref-app>' +
+            '</needs-content-child-template-ref-app>';
+        const view = createTestCmpAndDetectChanges(MyComp0, template);
+
+        view.detectChanges();
+        expect(view.nativeElement).toHaveText('OUTER');
+      });
+
       it('should contain the first view child', () => {
         const template = '<needs-view-child-read></needs-view-child-read>';
         const view = createTestCmpAndDetectChanges(MyComp0, template);
@@ -730,6 +741,23 @@ class NeedsContentChildWithRead {
   @ContentChild('nonExisting', {read: TextDirective}) nonExistingVar: TextDirective;
 }
 
+@Component({
+  selector: 'needs-content-child-template-ref',
+  template: '<div [ngTemplateOutlet]="templateRef"></div>'
+})
+class NeedsContentChildTemplateRef {
+  @ContentChild(TemplateRef) templateRef: TemplateRef<any>;
+}
+
+@Component({
+  selector: 'needs-content-child-template-ref-app',
+  template: '<needs-content-child-template-ref>' +
+      '<template>OUTER<template>INNER</template></template>' +
+      '</needs-content-child-template-ref>'
+})
+class NeedsContentChildTemplateRefApp {
+}
+
 @Component({
   selector: 'needs-view-children-read',
   template: '<div #q text="va"></div><div #w text="vb"></div>',

modules/@angular/core/test/linker/regression_integration_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, Injector, OpaqueToken, Pipe, PipeTransform, Provider} from '@angular/core';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, Component, Injector, OpaqueToken, Pipe, PipeTransform, Provider} from '@angular/core';
 import {TestBed} from '@angular/core/testing';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
@@ -119,7 +119,7 @@ function declareTests({useJit}: {useJit: boolean}) {
         expect(injector.get(token)).toEqual(tokenValue);
       });
 
-      it('should support providers with an anonymous function', () => {
+      it('should support providers with an anonymous function as token', () => {
         const token = () => true;
         const tokenValue = 1;
         const injector = createInjector([{provide: token, useValue: tokenValue}]);
@@ -147,6 +147,22 @@ function declareTests({useJit}: {useJit: boolean}) {
         const injector = createInjector([{provide: 'someToken', useValue: data}]);
         expect(injector.get('someToken')).toEqual(data);
       });
+
+      describe('ANALYZE_FOR_ENTRY_COMPONENTS providers', () => {
+
+        it('should support class instances', () => {
+          class SomeObject {
+            someMethod() {}
+          }
+
+          expect(
+              () => createInjector([
+                {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: new SomeObject(), multi: true}
+              ]))
+              .not.toThrow();
+        });
+      });
+
     });
 
     it('should allow logging a previous elements class binding via interpolation', () => {

modules/@angular/core/test/linker/view_injector_integration_spec.ts

@@ -421,7 +421,7 @@ export function main() {
         TestBed.overrideDirective(
             SimpleDirective, {set: {providers: [{provide: 'service', useValue: 'parentService'}]}});
         const el = createComponent(
-            '<div simpleDirective><template [ngIf]="true"><div *ngIf="true" needsService></div></template></div>');
+            '<div simpleDirective><ng-container *ngIf="true"><div *ngIf="true" needsService></div></ng-container></div>');
         expect(el.children[0].children[0].injector.get(NeedsService).service)
             .toEqual('parentService');
       });

modules/@angular/core/test/reflection/reflector_spec.ts

@@ -190,6 +190,8 @@ export function main() {
 
         class ChildNoDecorators extends Parent {}
 
+        class NoDecorators {}
+
         // Check that metadata for Parent was not changed!
         expect(reflector.annotations(Parent)).toEqual([new ClassDecorator({value: 'parent'})]);
 
@@ -199,6 +201,11 @@ export function main() {
 
         expect(reflector.annotations(ChildNoDecorators)).toEqual([new ClassDecorator(
             {value: 'parent'})]);
+
+        expect(reflector.annotations(NoDecorators)).toEqual([]);
+        expect(reflector.annotations(<any>{})).toEqual([]);
+        expect(reflector.annotations(<any>1)).toEqual([]);
+        expect(reflector.annotations(null)).toEqual([]);
       });
 
       it('should inherit parameters', () => {
@@ -226,6 +233,8 @@ export function main() {
           constructor(a: any, b: any, c: any) { super(null, null); }
         }
 
+        class NoDecorators {}
+
         // Check that metadata for Parent was not changed!
         expect(reflector.parameters(Parent)).toEqual([
           [A, new ParamDecorator('a')], [B, new ParamDecorator('b')]
@@ -242,6 +251,11 @@ export function main() {
         expect(reflector.parameters(ChildWithCtorNoDecorator)).toEqual([
           undefined, undefined, undefined
         ]);
+
+        expect(reflector.parameters(NoDecorators)).toEqual([]);
+        expect(reflector.parameters(<any>{})).toEqual([]);
+        expect(reflector.parameters(<any>1)).toEqual([]);
+        expect(reflector.parameters(null)).toEqual([]);
       });
 
       it('should inherit property metadata', () => {
@@ -263,6 +277,8 @@ export function main() {
           c: C;
         }
 
+        class NoDecorators {}
+
         // Check that metadata for Parent was not changed!
         expect(reflector.propMetadata(Parent)).toEqual({
           'a': [new PropDecorator('a')],
@@ -274,6 +290,11 @@ export function main() {
           'b': [new PropDecorator('b1'), new PropDecorator('b2')],
           'c': [new PropDecorator('c')]
         });
+
+        expect(reflector.propMetadata(NoDecorators)).toEqual({});
+        expect(reflector.propMetadata(<any>{})).toEqual({});
+        expect(reflector.propMetadata(<any>1)).toEqual({});
+        expect(reflector.propMetadata(null)).toEqual({});
       });
 
       it('should inherit lifecycle hooks', () => {
@@ -332,7 +353,7 @@ export function main() {
           static ctorParameters = () =>
               [{type: A, decorators: [{type: ParamDecorator, args: ['a']}]},
                {type: B, decorators: [{type: ParamDecorator, args: ['b']}]},
-          ];
+          ]
         }
 
         class Child extends Parent {}

modules/@angular/core/testing/private_export_testing.ts

@@ -9,7 +9,7 @@
 import * as mock_animation_player from './mock_animation_player';
 import * as test_compiler from './test_compiler';
 
-export var __core_private_testing__: {
+export const __core_private_testing__: {
   TestingCompiler: typeof test_compiler.TestingCompiler,
   _TestingCompiler?: test_compiler.TestingCompiler,
   TestingCompilerFactory: typeof test_compiler.TestingCompilerFactory,

modules/@angular/core/testing/test_bed.ts

@@ -262,7 +262,7 @@ export class TestBed implements Injector {
       } catch (e) {
         if (e.compType) {
           throw new Error(
-              `This test module uses the component ${stringify(e.compType)} which is using a "templateUrl", but they were never compiled. ` +
+              `This test module uses the component ${stringify(e.compType)} which is using a "templateUrl" or "styleUrls", but they were never compiled. ` +
               `Please call "TestBed.compileComponents" before your test.`);
         } else {
           throw e;

modules/@angular/core/testing/testing.ts

@@ -29,4 +29,4 @@ if (_global.beforeEach) {
 
 // TODO(juliemr): remove this, only used because we need to export something to have compilation
 // work.
-export var __core_private_testing_placeholder__ = '';
+export const __core_private_testing_placeholder__ = '';

modules/@angular/core/testing/testing_internal.ts

@@ -19,12 +19,12 @@ export {inject} from './test_bed';
 export * from './logger';
 export * from './ng_zone_mock';
 
-export var proxy: ClassDecorator = (t: any) => t;
+export const proxy: ClassDecorator = (t: any) => t;
 
 const _global = <any>(typeof window === 'undefined' ? global : window);
 
-export var afterEach: Function = _global.afterEach;
-export var expect: (actual: any) => jasmine.Matchers = _global.expect;
+export const afterEach: Function = _global.afterEach;
+export const expect: (actual: any) => jasmine.Matchers = _global.expect;
 
 const jsmBeforeEach = _global.beforeEach;
 const jsmDescribe = _global.describe;

modules/@angular/forms/src/validators.ts

@@ -14,8 +14,9 @@ import {isPresent} from './facade/lang';
 import {AbstractControl} from './model';
 import {isPromise} from './private_import_core';
 
-function isEmptyInputValue(value: any) {
-  return value == null || typeof value === 'string' && value.length === 0;
+function isEmptyInputValue(value: any): boolean {
+  // we don't check for string here so it also works with arrays
+  return value == null || value.length === 0;
 }
 
 /**

modules/@angular/forms/test/validators_spec.ts

@@ -48,6 +48,12 @@ export function main() {
 
       it('should accept zero as valid',
          () => { expect(Validators.required(new FormControl(0))).toBeNull(); });
+
+      it('should error on an empty array',
+         () => expect(Validators.required(new FormControl([]))).toEqual({'required': true}));
+
+      it('should not error on a non-empty array',
+         () => expect(Validators.required(new FormControl([1, 2]))).toBeNull());
     });
 
     describe('requiredTrue', () => {

modules/@angular/http/testing/mock_backend.ts

@@ -114,25 +114,78 @@ export class MockConnection implements Connection {
  * ### Example
  *
  * ```
- * import {BaseRequestOptions, Http} from '@angular/http';
- * import {MockBackend} from '@angular/http/testing';
- * it('should get some data', inject([AsyncTestCompleter], (async) => {
- *   var connection;
- *   var injector = Injector.resolveAndCreate([
- *     MockBackend,
- *     {provide: Http, useFactory: (backend, options) => {
- *       return new Http(backend, options);
- *     }, deps: [MockBackend, BaseRequestOptions]}]);
- *   var http = injector.get(Http);
- *   var backend = injector.get(MockBackend);
- *   //Assign any newly-created connection to local variable
- *   backend.connections.subscribe(c => connection = c);
- *   http.request('data.json').subscribe((res) => {
- *     expect(res.text()).toBe('awesome');
- *     async.done();
+ * import {Injectable, ReflectiveInjector} from '@angular/core';
+ * import {async, fakeAsync, tick} from '@angular/core/testing';
+ * import {BaseRequestOptions, ConnectionBackend, Http, RequestOptions} from '@angular/http';
+ * import {Response, ResponseOptions} from '@angular/http';
+ * import {MockBackend, MockConnection} from '@angular/http/testing';
+ *
+ * const HERO_ONE = 'HeroNrOne';
+ * const HERO_TWO = 'WillBeAlwaysTheSecond';
+ *
+ * @Injectable()
+ * class HeroService {
+ *   constructor(private http: Http) {}
+ *
+ *   getHeroes(): Promise<String[]> {
+ *     return this.http.get('myservices.de/api/heroes')
+ *         .toPromise()
+ *         .then(response => response.json().data)
+ *         .catch(e => this.handleError(e));
+ *   }
+ *
+ *   private handleError(error: any): Promise<any> {
+ *     console.error('An error occurred', error);
+ *     return Promise.reject(error.message || error);
+ *   }
+ * }
+ *
+ * describe('MockBackend HeroService Example', () => {
+ *   beforeEach(() => {
+ *     this.injector = ReflectiveInjector.resolveAndCreate([
+ *       {provide: ConnectionBackend, useClass: MockBackend},
+ *       {provide: RequestOptions, useClass: BaseRequestOptions},
+ *       Http,
+ *       HeroService,
+ *     ]);
+ *     this.heroService = this.injector.get(HeroService);
+ *     this.backend = this.injector.get(ConnectionBackend) as MockBackend;
+ *     this.backend.connections.subscribe((connection: any) => this.lastConnection = connection);
  *   });
- *   connection.mockRespond(new Response('awesome'));
- * }));
+ *
+ *   it('getHeroes() should query current service url', () => {
+ *     this.heroService.getHeroes();
+ *     expect(this.lastConnection).toBeDefined('no http service connection at all?');
+ *     expect(this.lastConnection.request.url).toMatch(/api\/heroes$/, 'url invalid');
+ *   });
+ *
+ *   it('getHeroes() should return some heroes', fakeAsync(() => {
+ *        let result: String[];
+ *        this.heroService.getHeroes().then((heroes: String[]) => result = heroes);
+ *        this.lastConnection.mockRespond(new Response(new ResponseOptions({
+ *          body: JSON.stringify({data: [HERO_ONE, HERO_TWO]}),
+ *        })));
+ *        tick();
+ *        expect(result.length).toEqual(2, 'should contain given amount of heroes');
+ *        expect(result[0]).toEqual(HERO_ONE, ' HERO_ONE should be the first hero');
+ *        expect(result[1]).toEqual(HERO_TWO, ' HERO_TWO should be the second hero');
+ *      }));
+ *
+ *   it('getHeroes() while server is down', fakeAsync(() => {
+ *        let result: String[];
+ *        let catchedError: any;
+ *        this.heroService.getHeroes()
+ *            .then((heroes: String[]) => result = heroes)
+ *            .catch((error: any) => catchedError = error);
+ *        this.lastConnection.mockRespond(new Response(new ResponseOptions({
+ *          status: 404,
+ *          statusText: 'URL not Found',
+ *        })));
+ *        tick();
+ *        expect(result).toBeUndefined();
+ *        expect(catchedError).toBeDefined();
+ *      }));
+ * });
  * ```
  *
  * This method only exists in the mock implementation, not in real Backends.
@@ -149,27 +202,30 @@ export class MockBackend implements ConnectionBackend {
    * ### Example
    *
    * ```
-   * import {Http, BaseRequestOptions, Response} from '@angular/http';
-   * import {MockBackend} from '@angular/http/testing';
-   * import {Injector, provide} from '@angular/core';
+   * import {ReflectiveInjector} from '@angular/core';
+   * import {fakeAsync, tick} from '@angular/core/testing';
+   * import {BaseRequestOptions, ConnectionBackend, Http, RequestOptions} from '@angular/http';
+   * import {Response, ResponseOptions} from '@angular/http';
+   * import {MockBackend, MockConnection} from '@angular/http/testing';
    *
-   * it('should get a response', () => {
-   *   var connection; //this will be set when a new connection is emitted from the backend.
-   *   var text; //this will be set from mock response
-   *   var injector = Injector.resolveAndCreate([
-   *     MockBackend,
-   *     {provide: Http, useFactory: (backend, options) => {
-   *       return new Http(backend, options);
-   *     }, deps: [MockBackend, BaseRequestOptions]}]);
-   *   var backend = injector.get(MockBackend);
-   *   var http = injector.get(Http);
-   *   backend.connections.subscribe(c => connection = c);
-   *   http.request('something.json').subscribe(res => {
-   *     text = res.text();
-   *   });
-   *   connection.mockRespond(new Response({body: 'Something'}));
-   *   expect(text).toBe('Something');
-   * });
+   * it('should get a response', fakeAsync(() => {
+   *      let connection:
+   *          MockConnection;  // this will be set when a new connection is emitted from the
+   *                           // backend.
+   *      let text: string;    // this will be set from mock response
+   *      let injector = ReflectiveInjector.resolveAndCreate([
+   *        {provide: ConnectionBackend, useClass: MockBackend},
+   *        {provide: RequestOptions, useClass: BaseRequestOptions},
+   *        Http,
+   *      ]);
+   *      let backend = injector.get(ConnectionBackend);
+   *      let http = injector.get(Http);
+   *      backend.connections.subscribe((c: MockConnection) => connection = c);
+   *      http.request('something.json').toPromise().then((res: any) => text = res.text());
+   *      connection.mockRespond(new Response(new ResponseOptions({body: 'Something'})));
+   *      tick();
+   *      expect(text).toBe('Something');
+   *    }));
    * ```
    *
    * This property only exists in the mock implementation, not in real Backends.