chore(release): cut the 2.1.2 release

The first code example for the reset function was invalid as it has a semi-colon instead of a colon for the last property in the json object.  Change the semi-colon to a colon.

Closes https://github.com/angular/angular/issues/12531

CHANGELOG.md

@@ -1,3 +1,86 @@
+<a name="2.1.2"></a>
+## [2.1.2](https://github.com/angular/angular/compare/2.1.1...2.1.2) (2016-10-27)
+
+### Bug Fixes
+
+* **compiler:** don't access view local variables nor pipes in host expressions ([#12396](https://github.com/angular/angular/issues/12396)) ([867494a](https://github.com/angular/angular/commit/867494a)), closes [#12004](https://github.com/angular/angular/issues/12004) [#12071](https://github.com/angular/angular/issues/12071)
+* **compiler:** walk third party modules ([#12453](https://github.com/angular/angular/issues/12453)) ([a838aba](https://github.com/angular/angular/commit/a838aba)), closes [#11889](https://github.com/angular/angular/issues/11889) [#12428](https://github.com/angular/angular/issues/12428)
+* **compiler:** remove double exports of template_ast ([7742ec0](https://github.com/angular/angular/commit/7742ec0))
+* **compiler:** use Maps instead of objects in selector implementation ([d321b0e](https://github.com/angular/angular/commit/d321b0e))
+* **compiler-cli:** fix types ([ef15364](https://github.com/angular/angular/commit/ef15364))
+* **compiler-cli:** assert that all pipes and directives are declared by a module  ([7221632](https://github.com/angular/angular/commit/7221632))
+* **http:** overwrite already set xsrf header ([b4265e0](https://github.com/angular/angular/commit/b4265e0))
+* **router:** add a test to make sure canDeactivate guards are called for aux routes ([fc60fa7](https://github.com/angular/angular/commit/fc60fa7)), closes [#11345](https://github.com/angular/angular/issues/11345)
+* **router:** canDeactivate guards are not triggered for componentless routes ([b741853](https://github.com/angular/angular/commit/b741853)), closes [#12375](https://github.com/angular/angular/issues/12375)
+* **router:** change router not to deactivate aux routes when navigating from a componentless routes ([52a853e](https://github.com/angular/angular/commit/52a853e))
+* **router:** disallow component routes with named outlets ([8f2fa0f](https://github.com/angular/angular/commit/8f2fa0f)), closes [#11208](https://github.com/angular/angular/issues/11208) [#11082](https://github.com/angular/angular/issues/11082)
+* **router:** preserve resolve data ([6ccbfd4](https://github.com/angular/angular/commit/6ccbfd4)), closes [#12306](https://github.com/angular/angular/issues/12306)
+
+
+
+<a name="2.2.0-beta.1"></a>
+# [2.2.0-beta.1](https://github.com/angular/angular/compare/2.2.0-beta.0...2.2.0-beta.1) (2016-10-27)
+
+### Code Refactoring
+
+* **upgrade:** re-export the new static upgrade APIs on new entry ([a26dd28](https://github.com/angular/angular/commit/a26dd28))
+
+
+### Features
+
+* **router:** export routerLinkActive w/ isActive property ([c9f58cf](https://github.com/angular/angular/commit/c9f58cf))
+
+
+### BREAKING CHANGES
+
+* upgrade: Four newly added APIs in 2.2.0-beta:
+downgradeComponent, downgradeInjectable, UpgradeComponent, and UpgradeModule are no longer exported by @angular/upgrade.
+Import these from @angular/upgrade/static instead.
+
+
+Note: The 2.2.0-beta.1 release also contains all the changes present in the 2.1.2 release.
+
+
+
+# [2.1.1](https://github.com/angular/angular/compare/2.1.0...2.1.1) (2016-10-20)
+
+### Bug Fixes
+
+* **compiler:** generate aot code for animation trigger output events ([#12291](https://github.com/angular/angular/issues/12291)) ([6e5f8b5](https://github.com/angular/angular/commit/6e5f8b5)), closes [#11707](https://github.com/angular/angular/issues/11707)
+* **compiler:** don't redeclare a var in the same scope ([#12386](https://github.com/angular/angular/issues/12386)) ([cca4a5c](https://github.com/angular/angular/commit/cca4a5c))
+* **core:** fix decorator default values ([bd1dcb5](https://github.com/angular/angular/commit/bd1dcb5))
+* **core:** fix property decorators ([3993279](https://github.com/angular/angular/commit/3993279)), closes [#12224](https://github.com/angular/angular/issues/12224)
+* **http:** make normalizeMethodName optimizer-compatible. ([#12370](https://github.com/angular/angular/issues/12370)) ([8409b65](https://github.com/angular/angular/commit/8409b65))
+* **router:** correctly export filter operator in es5 ([#12286](https://github.com/angular/angular/issues/12286)) ([27d7677](https://github.com/angular/angular/commit/27d7677))
+* **router:** do not update primary route if only secondary outlet is given ([#11797](https://github.com/angular/angular/issues/11797)) ([da5fc69](https://github.com/angular/angular/commit/da5fc69))
+* **router:** fix lazy loading triggered by redirects from wildcard routes ([5ae6915](https://github.com/angular/angular/commit/5ae6915)), closes [#12183](https://github.com/angular/angular/issues/12183)
+* **router:** module loader should start compiling modules when stubbedModules are set ([#11742](https://github.com/angular/angular/issues/11742)) ([b44b6ef](https://github.com/angular/angular/commit/b44b6ef))
+
+
+### Performance Improvements
+
+* **common:** optimize NgSwitch default case ([fdf4309](https://github.com/angular/angular/commit/fdf4309))
+
+
+
+<a name="2.2.0-beta.0"></a>
+# [2.2.0-beta.0](https://github.com/angular/angular/compare/2.1.0...2.2.0-beta.0) (2016-10-20)
+
+### Features
+
+* **common:** support narrow forms for month and weekdays in DatePipe ([#12297](https://github.com/angular/angular/issues/12297)) ([f77ab6a](https://github.com/angular/angular/commit/f77ab6a)), closes [#12294](https://github.com/angular/angular/issues/12294)
+* **forms:** add hasError and getError to AbstractControlDirective ([#11985](https://github.com/angular/angular/issues/11985)) ([592f40a](https://github.com/angular/angular/commit/592f40a)), closes [#7255](https://github.com/angular/angular/issues/7255)
+* **forms:** add ng-pending CSS class during async validation ([#11243](https://github.com/angular/angular/issues/11243)) ([97bc971](https://github.com/angular/angular/commit/97bc971)), closes [#10336](https://github.com/angular/angular/issues/10336)
+* **forms:** Added emitEvent to AbstractControl methods ([#11949](https://github.com/angular/angular/issues/11949)) ([b9fc090](https://github.com/angular/angular/commit/b9fc090))
+* **forms:** make 'parent' a public property of 'AbstractControl' ([#11855](https://github.com/angular/angular/issues/11855)) ([445e592](https://github.com/angular/angular/commit/445e592))
+* **forms:** Validator.pattern accepts a RegExp ([#12323](https://github.com/angular/angular/issues/12323)) ([bf60418](https://github.com/angular/angular/commit/bf60418))
+* **upgrade:** add support for AoT compiled upgrade applications ([d6791ff](https://github.com/angular/angular/commit/d6791ff)), closes [#12239](https://github.com/angular/angular/issues/12239)
+* **router:** add support for ng1/ng2 migration ([#12160](https://github.com/angular/angular/issues/12160)) ([8b9ab44](https://github.com/angular/angular/commit/8b9ab44))
+
+Note: The 2.2.0-beta.0 release also contains all the changes present in the 2.1.1 release.
+
+
+
 <a name="2.1.0"></a>
 # [2.1.0 incremental-metamorphosis](https://github.com/angular/angular/compare/2.1.0-rc.0...2.1.0) (2016-10-12)
 

modules/@angular/benchpress/src/metric/user_metric.ts

@@ -9,7 +9,6 @@
 import {Inject, Injectable} from '@angular/core';
 
 import {Options} from '../common_options';
-import {isNumber} from '../facade/lang';
 import {Metric} from '../metric';
 import {WebDriverAdapter} from '../web_driver_adapter';
 
@@ -44,7 +43,7 @@ export class UserMetric extends Metric {
     function getAndClearValues() {
       Promise.all(names.map(name => adapter.executeScript(`return window.${name}`)))
           .then((values: any[]) => {
-            if (values.every(isNumber)) {
+            if (values.every(v => typeof v === 'number')) {
               Promise.all(names.map(name => adapter.executeScript(`delete window.${name}`)))
                   .then((_: any[]) => {
                     let map: {[k: string]: any} = {};

modules/@angular/benchpress/src/reporter/json_file_reporter.ts

@@ -9,7 +9,6 @@
 import {Inject, Injectable, OpaqueToken} from '@angular/core';
 
 import {Options} from '../common_options';
-import {Json} from '../facade/lang';
 import {MeasureValues} from '../measure_values';
 import {Reporter} from '../reporter';
 import {SampleDescription} from '../sample_description';
@@ -39,12 +38,14 @@ export class JsonFileReporter extends Reporter {
     sortedProps(this._description.metrics).forEach((metricName) => {
       stats[metricName] = formatStats(validSample, metricName);
     });
-    var content = Json.stringify({
-      'description': this._description,
-      'stats': stats,
-      'completeSample': completeSample,
-      'validSample': validSample,
-    });
+    var content = JSON.stringify(
+        {
+          'description': this._description,
+          'stats': stats,
+          'completeSample': completeSample,
+          'validSample': validSample,
+        },
+        null, 2);
     var filePath = `${this._path}/${this._description.id}_${this._now().getTime()}.json`;
     return this._writeFile(filePath, content);
   }

modules/@angular/benchpress/src/reporter/util.ts

@@ -6,20 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-
-import {NumberWrapper} from '../facade/lang';
 import {MeasureValues} from '../measure_values';
 import {Statistic} from '../statistic';
 
 export function formatNum(n: number) {
-  return NumberWrapper.toFixed(n, 2);
+  return n.toFixed(2);
 }
 
 export function sortedProps(obj: {[key: string]: any}) {
-  var props: string[] = [];
-  props.push(...Object.keys(obj));
-  props.sort();
-  return props;
+  return Object.keys(obj).sort();
 }
 
 export function formatStats(validSamples: MeasureValues[], metricName: string): string {
@@ -29,5 +24,5 @@ export function formatStats(validSamples: MeasureValues[], metricName: string):
   var formattedMean = formatNum(mean);
   // Note: Don't use the unicode character for +- as it might cause
   // hickups for consoles...
-  return NumberWrapper.isNaN(cv) ? formattedMean : `${formattedMean}+-${Math.floor(cv)}%`;
+  return isNaN(cv) ? formattedMean : `${formattedMean}+-${Math.floor(cv)}%`;
 }

modules/@angular/benchpress/src/statistic.ts

@@ -6,8 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Math} from './facade/math';
-
 export class Statistic {
   static calculateCoefficientOfVariation(sample: number[], mean: number) {
     return Statistic.calculateStandardDeviation(sample, mean) / mean * 100;

modules/@angular/benchpress/src/validator/regression_slope_validator.ts

@@ -8,13 +8,10 @@
 
 import {Inject, Injectable, OpaqueToken} from '@angular/core';
 
-import {ListWrapper} from '../facade/collection';
 import {MeasureValues} from '../measure_values';
 import {Statistic} from '../statistic';
 import {Validator} from '../validator';
 
-
-
 /**
  * A validator that checks the regression slope of a specific metric.
  * Waits for the regression slope to be >=0.
@@ -40,17 +37,17 @@ export class RegressionSlopeValidator extends Validator {
 
   validate(completeSample: MeasureValues[]): MeasureValues[] {
     if (completeSample.length >= this._sampleSize) {
-      var latestSample = ListWrapper.slice(
-          completeSample, completeSample.length - this._sampleSize, completeSample.length);
-      var xValues: number[] = [];
-      var yValues: number[] = [];
-      for (var i = 0; i < latestSample.length; i++) {
+      const latestSample =
+          completeSample.slice(completeSample.length - this._sampleSize, completeSample.length);
+      const xValues: number[] = [];
+      const yValues: number[] = [];
+      for (let i = 0; i < latestSample.length; i++) {
         // For now, we only use the array index as x value.
         // TODO(tbosch): think about whether we should use time here instead
         xValues.push(i);
         yValues.push(latestSample[i].values[this._metric]);
       }
-      var regressionSlope = Statistic.calculateRegressionSlope(
+      const regressionSlope = Statistic.calculateRegressionSlope(
           xValues, Statistic.calculateMean(xValues), yValues, Statistic.calculateMean(yValues));
       return regressionSlope >= 0 ? latestSample : null;
     } else {

modules/@angular/benchpress/src/validator/size_validator.ts

@@ -8,12 +8,9 @@
 
 import {Inject, Injectable, OpaqueToken} from '@angular/core';
 
-import {ListWrapper} from '../facade/collection';
 import {MeasureValues} from '../measure_values';
 import {Validator} from '../validator';
 
-
-
 /**
  * A validator that waits for the sample to have a certain size.
  */
@@ -28,8 +25,7 @@ export class SizeValidator extends Validator {
 
   validate(completeSample: MeasureValues[]): MeasureValues[] {
     if (completeSample.length >= this._sampleSize) {
-      return ListWrapper.slice(
-          completeSample, completeSample.length - this._sampleSize, completeSample.length);
+      return completeSample.slice(completeSample.length - this._sampleSize, completeSample.length);
     } else {
       return null;
     }

modules/@angular/benchpress/src/webdriver/ios_driver_extension.ts

@@ -62,7 +62,7 @@ export class IOsDriverExtension extends WebDriverExtension {
       var startTime = record['startTime'];
       var endTime = record['endTime'];
 
-      if (type === 'FunctionCall' && (isBlank(data) || data['scriptName'] !== 'InjectedScript')) {
+      if (type === 'FunctionCall' && (data == null || data['scriptName'] !== 'InjectedScript')) {
         events.push(createStartEvent('script', startTime));
         endEvent = createEndEvent('script', endTime);
       } else if (type === 'Time') {

modules/@angular/benchpress/test/reporter/console_reporter_spec.ts

@@ -28,7 +28,7 @@ export function main() {
       if (!descriptions) {
         descriptions = [];
       }
-      if (isBlank(sampleId)) {
+      if (sampleId == null) {
         sampleId = 'null';
       }
       var providers: Provider[] = [

modules/@angular/benchpress/test/reporter/json_file_reporter_spec.ts

@@ -9,7 +9,7 @@
 import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
 
 import {JsonFileReporter, MeasureValues, Options, ReflectiveInjector, SampleDescription} from '../../index';
-import {Json, isPresent} from '../../src/facade/lang';
+import {isPresent} from '../../src/facade/lang';
 
 export function main() {
   describe('file reporter', () => {
@@ -51,7 +51,7 @@ export function main() {
                  [mv(0, 0, {'a': 3, 'b': 6}), mv(1, 1, {'a': 5, 'b': 9})]);
          var regExp = /somePath\/someId_\d+\.json/;
          expect(isPresent(loggedFile['filename'].match(regExp))).toBe(true);
-         var parsedContent = Json.parse(loggedFile['content']);
+         var parsedContent = JSON.parse(loggedFile['content']);
          expect(parsedContent).toEqual({
            'description': {
              'id': 'someId',

modules/@angular/benchpress/test/validator/regression_slope_validator_spec.ts

@@ -9,7 +9,6 @@
 import {describe, expect, it} from '@angular/core/testing/testing_internal';
 
 import {MeasureValues, ReflectiveInjector, RegressionSlopeValidator} from '../../index';
-import {ListWrapper} from '../../src/facade/collection';
 
 export function main() {
   describe('regression slope validator', () => {
@@ -44,17 +43,15 @@ export function main() {
     it('should return the last sampleSize runs when the regression slope is ==0', () => {
       createValidator({size: 2, metric: 'script'});
       var sample = [mv(0, 0, {'script': 1}), mv(1, 1, {'script': 1}), mv(2, 2, {'script': 1})];
-      expect(validator.validate(ListWrapper.slice(sample, 0, 2)))
-          .toEqual(ListWrapper.slice(sample, 0, 2));
-      expect(validator.validate(sample)).toEqual(ListWrapper.slice(sample, 1, 3));
+      expect(validator.validate(sample.slice(0, 2))).toEqual(sample.slice(0, 2));
+      expect(validator.validate(sample)).toEqual(sample.slice(1, 3));
     });
 
     it('should return the last sampleSize runs when the regression slope is >0', () => {
       createValidator({size: 2, metric: 'script'});
       var sample = [mv(0, 0, {'script': 1}), mv(1, 1, {'script': 2}), mv(2, 2, {'script': 3})];
-      expect(validator.validate(ListWrapper.slice(sample, 0, 2)))
-          .toEqual(ListWrapper.slice(sample, 0, 2));
-      expect(validator.validate(sample)).toEqual(ListWrapper.slice(sample, 1, 3));
+      expect(validator.validate(sample.slice(0, 2))).toEqual(sample.slice(0, 2));
+      expect(validator.validate(sample)).toEqual(sample.slice(1, 3));
     });
 
   });

modules/@angular/benchpress/test/validator/size_validator_spec.ts

@@ -9,7 +9,6 @@
 import {describe, expect, it} from '@angular/core/testing/testing_internal';
 
 import {MeasureValues, ReflectiveInjector, SizeValidator} from '../../index';
-import {ListWrapper} from '../../src/facade/collection';
 
 export function main() {
   describe('size validator', () => {
@@ -37,9 +36,8 @@ export function main() {
     it('should return the last sampleSize runs when it has at least the given size', () => {
       createValidator(2);
       var sample = [mv(0, 0, {'a': 1}), mv(1, 1, {'b': 2}), mv(2, 2, {'c': 3})];
-      expect(validator.validate(ListWrapper.slice(sample, 0, 2)))
-          .toEqual(ListWrapper.slice(sample, 0, 2));
-      expect(validator.validate(sample)).toEqual(ListWrapper.slice(sample, 1, 3));
+      expect(validator.validate(sample.slice(0, 2))).toEqual(sample.slice(0, 2));
+      expect(validator.validate(sample)).toEqual(sample.slice(1, 3));
     });
 
   });

modules/@angular/benchpress/test/webdriver/chrome_driver_extension_spec.ts

@@ -9,7 +9,7 @@
 import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
 
 import {ChromeDriverExtension, Options, ReflectiveInjector, WebDriverAdapter, WebDriverExtension} from '../../index';
-import {Json, isBlank} from '../../src/facade/lang';
+import {isBlank} from '../../src/facade/lang';
 import {TraceEventFactory} from '../trace_event_factory';
 
 export function main() {
@@ -398,8 +398,8 @@ class MockDriverAdapter extends WebDriverAdapter {
     if (type === 'performance') {
       return Promise.resolve(this._events.map(
           (event) => ({
-            'message':
-                Json.stringify({'message': {'method': this._messageMethod, 'params': event}})
+            'message': JSON.stringify(
+                {'message': {'method': this._messageMethod, 'params': event}}, null, 2)
           })));
     } else {
       return null;

modules/@angular/benchpress/test/webdriver/ios_driver_extension_spec.ts

@@ -9,7 +9,6 @@
 import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
 
 import {IOsDriverExtension, ReflectiveInjector, WebDriverAdapter, WebDriverExtension} from '../../index';
-import {Json} from '../../src/facade/lang';
 import {TraceEventFactory} from '../trace_event_factory';
 
 export function main() {
@@ -184,8 +183,9 @@ class MockDriverAdapter extends WebDriverAdapter {
     if (type === 'performance') {
       return Promise.resolve(this._perfRecords.map(function(record) {
         return {
-          'message': Json.stringify(
-              {'message': {'method': 'Timeline.eventRecorded', 'params': {'record': record}}})
+          'message': JSON.stringify(
+              {'message': {'method': 'Timeline.eventRecorded', 'params': {'record': record}}}, null,
+              2)
         };
       }));
     } else {

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

@@ -11,8 +11,6 @@ import {CollectionChangeRecord, Directive, DoCheck, ElementRef, Input, IterableD
 import {isListLikeIterable} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 
-
-
 /**
  * @ngModule CommonModule
  *
@@ -31,11 +29,11 @@ import {isPresent} from '../facade/lang';
  *
  * @description
  *
- * The CSS classes are updated as follow depending on the type of the expression evaluation:
- * - `string` - the CSS classes listed in a string (space delimited) are added,
- * - `Array` - the CSS classes (Array elements) are added,
- * - `Object` - keys are CSS class names that get added when the expression given in the value
- *              evaluates to a truthy value, otherwise class are removed.
+ * The CSS classes are updated as follows, depending on the type of the expression evaluation:
+ * - `string` - the CSS classes listed in the string (space delimited) are added,
+ * - `Array` - the CSS classes declared as Array elements are added,
+ * - `Object` - keys are CSS classes that get added when the expression given in the value
+ *              evaluates to a truthy value, otherwise they are removed.
  *
  * @stable
  */
@@ -50,7 +48,6 @@ export class NgClass implements DoCheck {
       private _iterableDiffers: IterableDiffers, private _keyValueDiffers: KeyValueDiffers,
       private _ngEl: ElementRef, private _renderer: Renderer) {}
 
-
   @Input('class')
   set klass(v: string) {
     this._applyInitialClasses(true);

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

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

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

@@ -7,7 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
-import {isBlank, isStringMap} from '../facade/lang';
+import {isBlank} from '../facade/lang';
 import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
@@ -31,10 +31,10 @@ export class I18nSelectPipe implements PipeTransform {
   transform(value: string, mapping: {[key: string]: string}): string {
     if (isBlank(value)) return '';
 
-    if (!isStringMap(mapping)) {
+    if (typeof mapping !== 'object' || mapping === null) {
       throw new InvalidPipeArgumentError(I18nSelectPipe, mapping);
     }
 
-    return mapping.hasOwnProperty(value) ? mapping[value] : '';
+    return mapping[value] || '';
   }
 }

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

@@ -8,10 +8,6 @@
 
 import {Pipe, PipeTransform} from '@angular/core';
 
-import {Json} from '../facade/lang';
-
-
-
 /**
  * @ngModule CommonModule
  * @whatItDoes Converts value into JSON string.
@@ -27,5 +23,5 @@ import {Json} from '../facade/lang';
  */
 @Pipe({name: 'json', pure: false})
 export class JsonPipe implements PipeTransform {
-  transform(value: any): string { return Json.stringify(value); }
+  transform(value: any): string { return JSON.stringify(value, null, 2); }
 }

modules/@angular/common/test/pipes/json_pipe_spec.ts

@@ -11,8 +11,6 @@ import {Component} from '@angular/core';
 import {TestBed, async} from '@angular/core/testing';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
-import {Json} from '../../src/facade/lang';
-
 export function main() {
   describe('JsonPipe', () => {
     var regNewLine = '\n';
@@ -48,7 +46,7 @@ export function main() {
 
       it('should return JSON-formatted string similar to Json.stringify', () => {
         var dream1 = normalize(pipe.transform(inceptionObj));
-        var dream2 = normalize(Json.stringify(inceptionObj));
+        var dream2 = normalize(JSON.stringify(inceptionObj, null, 2));
         expect(dream1).toEqual(dream2);
       });
     });
@@ -74,7 +72,6 @@ export function main() {
            mutable.push(2);
            fixture.detectChanges();
            expect(fixture.nativeElement).toHaveText('[\n  1,\n  2\n]');
-
          }));
     });
   });

modules/@angular/compiler-cli/README.md

@@ -27,7 +27,7 @@ Then you can add an import statement in the `bootstrap` allowing you to bootstra
 generated code:
 
 ```typescript
-main_module.ts
+main.module.ts
 -------------
 import {BrowserModule} from '@angular/platform-browser';
 import {Component, NgModule, ApplicationRef} from '@angular/core';
@@ -49,7 +49,7 @@ export class MainModule {
 bootstrap.ts
 -------------
 
-import {MainModuleNgFactory} from './main_module.ngfactory';
+import {MainModuleNgFactory} from './main.module.ngfactory';
 import {platformBrowser} from '@angular/platform-browser';
 
 platformBrowser().bootstrapModuleFactory(MainModuleNgFactory);

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

@@ -7,6 +7,7 @@
  */
 
 export {CodeGenerator} from './src/codegen';
+export {Extractor} from './src/extractor';
 export {NodeReflectorHostContext, ReflectorHost, ReflectorHostContext} from './src/reflector_host';
 export {StaticReflector, StaticReflectorHost, StaticSymbol} from './src/static_reflector';
 

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

@@ -0,0 +1,18 @@
+/**
+ * @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} from '@angular/core';
+
+@Component({
+  selector: 'use-third-party',
+  template: '<third-party-comp [thirdParty]="title"></third-party-comp>' +
+      '<another-third-party-comp></another-third-party-comp>',
+})
+export class ComponentUsingThirdParty {
+  title: string = 'from 3rd party';
+}

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

@@ -12,6 +12,10 @@
                 <source>Welcome</source>
                 <target>tervetuloa</target>
             </trans-unit>
+            <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+                <source>other-3rdP-component</source>
+                <target>other-3rdP-component</target>
+            </trans-unit>
         </body>
     </file>
 </xliff>

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

@@ -9,4 +9,5 @@
 <translationbundle>
   <translation id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4">käännä teksti</translation>
   <translation id="65cc4ab3b4c438e07c89be2b677d08369fb62da2">tervetuloa</translation>
+  <translation id="63a85808f03b8181e36a952e0fa38202c2304862">other-3rdP-component</translation>
 </translationbundle>

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

@@ -11,9 +11,12 @@ import {FormsModule} from '@angular/forms';
 import {BrowserModule} from '@angular/platform-browser';
 import {MdButtonModule} from '@angular2-material/button';
 
+import {ThirdpartyModule} from '../third_party_src/module';
+
 import {MultipleComponentsMyComp, NextComp} from './a/multiple_components';
 import {AnimateCmp} from './animate';
 import {BasicComp} from './basic';
+import {ComponentUsingThirdParty} from './comp_using_3rdp';
 import {CompWithAnalyzeEntryComponentsProvider, CompWithEntryComponents} from './entry_components';
 import {CompConsumingEvents, CompUsingPipes, CompWithProviders, CompWithReferences, DirPublishingEvents, ModuleUsingCustomElements} from './features';
 import {CompUsingRootModuleDirectiveAndPipe, SomeDirectiveInRootModule, SomePipeInRootModule, SomeService, someLibModuleWithProviders} from './module_fixtures';
@@ -22,35 +25,47 @@ import {CompForChildQuery, CompWithChildQuery, CompWithDirectiveChild, Directive
 
 @NgModule({
   declarations: [
-    SomeDirectiveInRootModule,
-    SomePipeInRootModule,
     AnimateCmp,
     BasicComp,
+    CompConsumingEvents,
     CompForChildQuery,
-    CompWithEntryComponents,
+    CompUsingPipes,
+    CompUsingRootModuleDirectiveAndPipe,
     CompWithAnalyzeEntryComponentsProvider,
-    ProjectingComp,
     CompWithChildQuery,
     CompWithDirectiveChild,
+    CompWithEntryComponents,
     CompWithNgContent,
-    CompUsingRootModuleDirectiveAndPipe,
     CompWithProviders,
     CompWithReferences,
-    CompUsingPipes,
-    CompConsumingEvents,
+    DirectiveForQuery,
     DirPublishingEvents,
     MultipleComponentsMyComp,
-    DirectiveForQuery,
     NextComp,
+    ProjectingComp,
+    SomeDirectiveInRootModule,
+    SomePipeInRootModule,
+    ComponentUsingThirdParty,
   ],
   imports: [
-    BrowserModule, FormsModule, someLibModuleWithProviders(), ModuleUsingCustomElements,
-    MdButtonModule
+    BrowserModule,
+    FormsModule,
+    MdButtonModule,
+    ModuleUsingCustomElements,
+    someLibModuleWithProviders(),
+    ThirdpartyModule,
   ],
   providers: [SomeService],
   entryComponents: [
-    AnimateCmp, BasicComp, CompWithEntryComponents, CompWithAnalyzeEntryComponentsProvider,
-    ProjectingComp, CompWithChildQuery, CompUsingRootModuleDirectiveAndPipe, CompWithReferences
+    AnimateCmp,
+    BasicComp,
+    CompUsingRootModuleDirectiveAndPipe,
+    CompWithAnalyzeEntryComponentsProvider,
+    CompWithChildQuery,
+    CompWithEntryComponents,
+    CompWithReferences,
+    ProjectingComp,
+    ComponentUsingThirdParty,
   ]
 })
 export class MainModule {

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

@@ -43,13 +43,13 @@ describe('template codegen output', () => {
   });
 
   it('should be able to create the basic component', () => {
-    var compFixture = createComponent(BasicComp);
+    const compFixture = createComponent(BasicComp);
     expect(compFixture.componentInstance).toBeTruthy();
   });
 
   it('should support ngIf', () => {
-    var compFixture = createComponent(BasicComp);
-    var debugElement = compFixture.debugElement;
+    const compFixture = createComponent(BasicComp);
+    const debugElement = compFixture.debugElement;
     expect(debugElement.children.length).toBe(3);
 
     compFixture.componentInstance.ctxBool = true;
@@ -59,8 +59,8 @@ describe('template codegen output', () => {
   });
 
   it('should support ngFor', () => {
-    var compFixture = createComponent(BasicComp);
-    var debugElement = compFixture.debugElement;
+    const compFixture = createComponent(BasicComp);
+    const debugElement = compFixture.debugElement;
     expect(debugElement.children.length).toBe(3);
 
     // test NgFor
@@ -83,11 +83,9 @@ describe('template codegen output', () => {
     });
 
     it('should support i18n for content tags', () => {
-      const compFixture = createComponent(BasicComp);
-      const debugElement = compFixture.debugElement;
-      const containerElement = <any>debugElement.nativeElement;
-      const pElement = <any>containerElement.children.find((c: any) => c.name == 'p');
-      const pText = <string>pElement.children.map((c: any) => c.data).join('').trim();
+      const containerElement = createComponent(BasicComp).nativeElement;
+      const pElement = containerElement.children.find((c: any) => c.name == 'p');
+      const pText = pElement.children.map((c: any) => c.data).join('').trim();
       expect(pText).toBe('tervetuloa');
     });
   });

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

@@ -34,6 +34,7 @@ const EXPECTED_XMB = `<?xml version="1.0" encoding="UTF-8" ?>
 <!ELEMENT ex (#PCDATA)>
 ]>
 <messagebundle>
+  <msg id="63a85808f03b8181e36a952e0fa38202c2304862">other-3rdP-component</msg>
   <msg id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" desc="desc" meaning="meaning">translate me</msg>
   <msg id="65cc4ab3b4c438e07c89be2b677d08369fb62da2">Welcome</msg>
 </messagebundle>
@@ -43,6 +44,10 @@ const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
 <xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
   <file source-language="en" datatype="plaintext" original="ng2.template">
     <body>
+      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+        <source>other-3rdP-component</source>
+        <target/>
+      </trans-unit>
       <trans-unit id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" datatype="html">
         <source>translate me</source>
         <target/>

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

@@ -7,6 +7,7 @@
  */
 import './init';
 
+import {ComponentUsingThirdParty} from '../src/comp_using_3rdp';
 import {MainModule} from '../src/module';
 import {CompUsingLibModuleDirectiveAndPipe, CompUsingRootModuleDirectiveAndPipe, SOME_TOKEN, ServiceUsingLibModule, SomeLibModule, SomeService} from '../src/module_fixtures';
 
@@ -15,9 +16,9 @@ import {createComponent, createModule} from './util';
 describe('NgModule', () => {
   it('should support providers', () => {
     const moduleRef = createModule();
-    expect(moduleRef.instance instanceof MainModule).toBe(true);
-    expect(moduleRef.injector.get(MainModule) instanceof MainModule).toBe(true);
-    expect(moduleRef.injector.get(SomeService) instanceof SomeService).toBe(true);
+    expect(moduleRef.instance instanceof MainModule).toEqual(true);
+    expect(moduleRef.injector.get(MainModule) instanceof MainModule).toEqual(true);
+    expect(moduleRef.injector.get(SomeService) instanceof SomeService).toEqual(true);
   });
 
   it('should support entryComponents components', () => {
@@ -26,7 +27,7 @@ describe('NgModule', () => {
         CompUsingRootModuleDirectiveAndPipe);
     expect(cf.componentType).toBe(CompUsingRootModuleDirectiveAndPipe);
     const compRef = cf.create(moduleRef.injector);
-    expect(compRef.instance instanceof CompUsingRootModuleDirectiveAndPipe).toBe(true);
+    expect(compRef.instance instanceof CompUsingRootModuleDirectiveAndPipe).toEqual(true);
   });
 
   it('should support entryComponents via the ANALYZE_FOR_ENTRY_COMPONENTS provider and function providers in components',
@@ -42,12 +43,30 @@ describe('NgModule', () => {
        ]);
      });
 
+  describe('third-party modules', () => {
+    // https://github.com/angular/angular/issues/11889
+    it('should support third party entryComponents components', () => {
+      const fixture = createComponent(ComponentUsingThirdParty);
+      const thirdPComps = fixture.nativeElement.children;
+      expect(thirdPComps[0].children[0].children[0].data).toEqual('3rdP-component');
+      expect(thirdPComps[1].children[0].children[0].data).toEqual('other-3rdP-component');
+    });
+
+    // https://github.com/angular/angular/issues/12428
+    it('should support third party directives', () => {
+      const fixture = createComponent(ComponentUsingThirdParty);
+      const debugElement = fixture.debugElement;
+      fixture.detectChanges();
+      expect(debugElement.children[0].properties['title']).toEqual('from 3rd party');
+    });
+  });
+
   it('should support module directives and pipes', () => {
     const compFixture = createComponent(CompUsingRootModuleDirectiveAndPipe);
     compFixture.detectChanges();
 
     const debugElement = compFixture.debugElement;
-    expect(debugElement.children[0].properties['title']).toBe('transformed someValue');
+    expect(debugElement.children[0].properties['title']).toEqual('transformed someValue');
   });
 
   it('should support module directives and pipes on lib modules', () => {
@@ -55,10 +74,10 @@ describe('NgModule', () => {
     compFixture.detectChanges();
 
     const debugElement = compFixture.debugElement;
-    expect(debugElement.children[0].properties['title']).toBe('transformed someValue');
+    expect(debugElement.children[0].properties['title']).toEqual('transformed someValue');
 
-    expect(debugElement.injector.get(SomeLibModule) instanceof SomeLibModule).toBe(true);
+    expect(debugElement.injector.get(SomeLibModule) instanceof SomeLibModule).toEqual(true);
     expect(debugElement.injector.get(ServiceUsingLibModule) instanceof ServiceUsingLibModule)
-        .toBe(true);
+        .toEqual(true);
   });
 });

modules/@angular/compiler-cli/integrationtest/third_party_src/README.md

@@ -0,0 +1,8 @@
+This folder emulates consuming precompiled modules and components.
+It is compiled separately from the other sources under `src`
+to only generate `*.js` / `*.d.ts` / `*.metadata.json` files,
+but no `*.ngfactory.ts` files.
+
+** WARNING **
+Do not import components/directives from here directly as we want to test that ngc still compiles 
+them when they are not imported.

modules/@angular/compiler-cli/integrationtest/third_party_src/comp.ts

@@ -6,7 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {global} from './lang';
+import {Component} from '@angular/core';
 
-export var Math = global.Math;
-export var NaN: any /** TODO #???? */ = typeof NaN;
+@Component({
+  selector: 'third-party-comp',
+  template: '<div>3rdP-component</div>',
+})
+export class ThirdPartyComponent {
+}

modules/@angular/compiler-cli/integrationtest/third_party_src/directive.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 {Directive, Input} from '@angular/core';
+
+@Directive({
+  selector: '[thirdParty]',
+  host: {'[title]': 'thirdParty'},
+})
+export class ThirdPartyDirective {
+  @Input() thirdParty: string;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * @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 {NgModule} from '@angular/core';
+
+import {ThirdPartyComponent} from './comp';
+import {ThirdPartyDirective} from './directive';
+import {AnotherThirdPartyModule} from './other_module';
+
+@NgModule({
+  declarations: [
+    ThirdPartyComponent,
+    ThirdPartyDirective,
+  ],
+  exports: [
+    AnotherThirdPartyModule,
+    ThirdPartyComponent,
+    ThirdPartyDirective,
+  ],
+  imports: [AnotherThirdPartyModule]
+})
+export class ThirdpartyModule {
+}

modules/@angular/compiler-cli/integrationtest/third_party_src/other_comp.ts

@@ -0,0 +1,16 @@
+/**
+ * @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} from '@angular/core';
+
+@Component({
+  selector: 'another-third-party-comp',
+  template: '<div i18n>other-3rdP-component</div>',
+})
+export class AnotherThirdpartyComponent {
+}

modules/@angular/compiler-cli/integrationtest/third_party_src/other_module.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 {NgModule} from '@angular/core';
+import {AnotherThirdpartyComponent} from './other_comp';
+
+@NgModule({
+  declarations: [AnotherThirdpartyComponent],
+  exports: [AnotherThirdpartyComponent],
+})
+export class AnotherThirdPartyModule {
+}

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

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

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

@@ -0,0 +1,29 @@
+{
+  "angularCompilerOptions": {
+    // For TypeScript 1.8, we have to lay out generated files
+    // in the same source directory with your code.
+    "genDir": ".",
+    "debug": true
+  },
+
+  "compilerOptions": {
+    "target": "es5",
+    "experimentalDecorators": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "rootDir": "",
+    "declaration": true,
+    "lib": ["es6", "dom"],
+    "baseUrl": "."
+  },
+
+  "files": [
+    "src/module",
+    "src/bootstrap",
+    "test/all_spec",
+    "benchmarks/src/tree/ng2/index_aot.ts",
+    "benchmarks/src/tree/ng2_switch/index_aot.ts",
+    "benchmarks/src/largetable/ng2/index_aot.ts",
+    "benchmarks/src/largetable/ng2_switch/index_aot.ts"
+  ]
+}

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

@@ -1,29 +0,0 @@
-{
-    "angularCompilerOptions": {
-      // For TypeScript 1.8, we have to lay out generated files
-      // in the same source directory with your code.
-      "genDir": ".",
-      "debug": true
-    },
-
-    "compilerOptions": {
-        "target": "es5",
-        "experimentalDecorators": true,
-        "noImplicitAny": true,
-        "moduleResolution": "node",
-        "rootDir": "",
-        "declaration": true,
-        "lib": ["es6", "dom"],
-        "baseUrl": "."
-    },
-
-    "files": [
-        "src/module",
-        "src/bootstrap",
-        "test/all_spec",
-        "benchmarks/src/tree/ng2/index_aot.ts",
-        "benchmarks/src/tree/ng2_switch/index_aot.ts",
-        "benchmarks/src/largetable/ng2/index_aot.ts",
-        "benchmarks/src/largetable/ng2_switch/index_aot.ts"
-    ]
-}

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

@@ -11,13 +11,12 @@
  * Intended to be used in a build step.
  */
 import * as compiler from '@angular/compiler';
-import {Component, NgModule, ViewEncapsulation} from '@angular/core';
+import {ViewEncapsulation} from '@angular/core';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import * as path from 'path';
 import * as ts from 'typescript';
 
 import {PathMappedReflectorHost} from './path_mapped_reflector_host';
-import {CompileMetadataResolver, DirectiveNormalizer, DomElementSchemaRegistry, HtmlParser, Lexer, NgModuleCompiler, Parser, StyleCompiler, TemplateParser, TypeScriptEmitter, ViewCompiler} from './private_import_compiler';
 import {Console} from './private_import_core';
 import {ReflectorHost, ReflectorHostContext} from './reflector_host';
 import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
@@ -36,73 +35,16 @@ const PREAMBLE = `/**
 
 `;
 
-export class CodeGeneratorModuleCollector {
-  constructor(
-      private staticReflector: StaticReflector, private reflectorHost: StaticReflectorHost,
-      private program: ts.Program, private options: AngularCompilerOptions) {}
-
-  getModuleSymbols(program: ts.Program): {fileMetas: FileMetadata[], ngModules: StaticSymbol[]} {
-    // Compare with false since the default should be true
-    const skipFileNames = (this.options.generateCodeForLibraries === false) ?
-        GENERATED_OR_DTS_FILES :
-        GENERATED_FILES;
-    let filePaths = this.program.getSourceFiles()
-                        .filter(sf => !skipFileNames.test(sf.fileName))
-                        .map(sf => this.reflectorHost.getCanonicalFileName(sf.fileName));
-    const fileMetas = filePaths.map((filePath) => this.readFileMetadata(filePath));
-    const ngModules = fileMetas.reduce((ngModules, fileMeta) => {
-      ngModules.push(...fileMeta.ngModules);
-      return ngModules;
-    }, <StaticSymbol[]>[]);
-    return {fileMetas, ngModules};
-  }
-
-  private readFileMetadata(absSourcePath: string): FileMetadata {
-    const moduleMetadata = this.staticReflector.getModuleMetadata(absSourcePath);
-    const result: FileMetadata = {components: [], ngModules: [], fileUrl: absSourcePath};
-    if (!moduleMetadata) {
-      console.log(`WARNING: no metadata found for ${absSourcePath}`);
-      return result;
-    }
-    const metadata = moduleMetadata['metadata'];
-    const symbols = metadata && Object.keys(metadata);
-    if (!symbols || !symbols.length) {
-      return result;
-    }
-    for (const symbol of symbols) {
-      if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
-        // Ignore symbols that are only included to record error information.
-        continue;
-      }
-      const staticType = this.reflectorHost.findDeclaration(absSourcePath, symbol, absSourcePath);
-      const annotations = this.staticReflector.annotations(staticType);
-      annotations.forEach((annotation) => {
-        if (annotation instanceof NgModule) {
-          result.ngModules.push(staticType);
-        } else if (annotation instanceof Component) {
-          result.components.push(staticType);
-        }
-      });
-    }
-    return result;
-  }
-}
-
 export class CodeGenerator {
-  private moduleCollector: CodeGeneratorModuleCollector;
-
   constructor(
       private options: AngularCompilerOptions, private program: ts.Program,
       public host: ts.CompilerHost, private staticReflector: StaticReflector,
-      private compiler: compiler.OfflineCompiler, private reflectorHost: StaticReflectorHost) {
-    this.moduleCollector =
-        new CodeGeneratorModuleCollector(staticReflector, reflectorHost, program, options);
-  }
+      private compiler: compiler.OfflineCompiler, private reflectorHost: StaticReflectorHost) {}
 
   // Write codegen in a directory structure matching the sources.
   private calculateEmitPath(filePath: string): string {
     let root = this.options.basePath;
-    for (let eachRootDir of this.options.rootDirs || []) {
+    for (const eachRootDir of this.options.rootDirs || []) {
       if (this.options.trace) {
         console.log(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
       }
@@ -112,31 +54,28 @@ export class CodeGenerator {
     }
 
     // transplant the codegen path to be inside the `genDir`
-    var relativePath: string = path.relative(root, filePath);
+    let relativePath: string = path.relative(root, filePath);
     while (relativePath.startsWith('..' + path.sep)) {
       // Strip out any `..` path such as: `../node_modules/@foo` as we want to put everything
       // into `genDir`.
       relativePath = relativePath.substr(3);
     }
+
     return path.join(this.options.genDir, relativePath);
   }
 
-  codegen(): Promise<any> {
-    const {fileMetas, ngModules} = this.moduleCollector.getModuleSymbols(this.program);
-    const analyzedNgModules = this.compiler.analyzeModules(ngModules);
-    return Promise.all(fileMetas.map(
-        (fileMeta) =>
-            this.compiler
-                .compile(
-                    fileMeta.fileUrl, analyzedNgModules, fileMeta.components, fileMeta.ngModules)
-                .then((generatedModules) => {
-                  generatedModules.forEach((generatedModule) => {
-                    const sourceFile = this.program.getSourceFile(fileMeta.fileUrl);
-                    const emitPath = this.calculateEmitPath(generatedModule.moduleUrl);
-                    this.host.writeFile(
-                        emitPath, PREAMBLE + generatedModule.source, false, () => {}, [sourceFile]);
-                  });
-                })));
+  codegen(options: {transitiveModules: boolean}): Promise<any> {
+    const staticSymbols =
+        extractProgramSymbols(this.program, this.staticReflector, this.reflectorHost, this.options);
+
+    return this.compiler.compileModules(staticSymbols, options).then(generatedModules => {
+      generatedModules.forEach(generatedModule => {
+        const sourceFile = this.program.getSourceFile(generatedModule.fileUrl);
+        const emitPath = this.calculateEmitPath(generatedModule.moduleUrl);
+        this.host.writeFile(
+            emitPath, PREAMBLE + generatedModule.source, false, () => {}, [sourceFile]);
+      });
+    });
   }
 
   static create(
@@ -173,36 +112,72 @@ export class CodeGenerator {
     const staticReflector = new StaticReflector(reflectorHost);
     StaticAndDynamicReflectionCapabilities.install(staticReflector);
     const htmlParser =
-        new compiler.I18NHtmlParser(new HtmlParser(), transContent, cliOptions.i18nFormat);
+        new compiler.I18NHtmlParser(new compiler.HtmlParser(), transContent, cliOptions.i18nFormat);
     const config = new compiler.CompilerConfig({
       genDebugInfo: options.debug === true,
       defaultEncapsulation: ViewEncapsulation.Emulated,
       logBindingUpdate: false,
       useJit: false
     });
-    const normalizer = new DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
-    const expressionParser = new Parser(new Lexer());
-    const elementSchemaRegistry = new DomElementSchemaRegistry();
+    const normalizer =
+        new compiler.DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
+    const expressionParser = new compiler.Parser(new compiler.Lexer());
+    const elementSchemaRegistry = new compiler.DomElementSchemaRegistry();
     const console = new Console();
-    const tmplParser =
-        new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
-    const resolver = new CompileMetadataResolver(
+    const tmplParser = new compiler.TemplateParser(
+        expressionParser, elementSchemaRegistry, htmlParser, console, []);
+    const resolver = new compiler.CompileMetadataResolver(
         new compiler.NgModuleResolver(staticReflector),
         new compiler.DirectiveResolver(staticReflector), new compiler.PipeResolver(staticReflector),
         elementSchemaRegistry, staticReflector);
     // TODO(vicb): do not pass cliOptions.i18nFormat here
     const offlineCompiler = new compiler.OfflineCompiler(
-        resolver, normalizer, tmplParser, new StyleCompiler(urlResolver), new ViewCompiler(config),
-        new NgModuleCompiler(), new TypeScriptEmitter(reflectorHost), cliOptions.locale,
-        cliOptions.i18nFormat);
+        resolver, normalizer, tmplParser, new compiler.StyleCompiler(urlResolver),
+        new compiler.ViewCompiler(config, elementSchemaRegistry),
+        new compiler.DirectiveWrapperCompiler(
+            config, expressionParser, elementSchemaRegistry, console),
+        new compiler.NgModuleCompiler(), new compiler.TypeScriptEmitter(reflectorHost),
+        cliOptions.locale, cliOptions.i18nFormat);
 
     return new CodeGenerator(
         options, program, compilerHost, staticReflector, offlineCompiler, reflectorHost);
   }
 }
 
-export interface FileMetadata {
-  fileUrl: string;
-  components: StaticSymbol[];
-  ngModules: StaticSymbol[];
-}
+export function extractProgramSymbols(
+    program: ts.Program, staticReflector: StaticReflector, reflectorHost: StaticReflectorHost,
+    options: AngularCompilerOptions): StaticSymbol[] {
+  // Compare with false since the default should be true
+  const skipFileNames =
+      options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
+
+  const staticSymbols: StaticSymbol[] = [];
+
+  program.getSourceFiles()
+      .filter(sourceFile => !skipFileNames.test(sourceFile.fileName))
+      .forEach(sourceFile => {
+        const absSrcPath = reflectorHost.getCanonicalFileName(sourceFile.fileName);
+
+        const moduleMetadata = staticReflector.getModuleMetadata(absSrcPath);
+        if (!moduleMetadata) {
+          console.log(`WARNING: no metadata found for ${absSrcPath}`);
+          return;
+        }
+
+        const metadata = moduleMetadata['metadata'];
+
+        if (!metadata) {
+          return;
+        }
+
+        for (const symbol of Object.keys(metadata)) {
+          if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
+            // Ignore symbols that are only included to record error information.
+            continue;
+          }
+          staticSymbols.push(reflectorHost.findDeclaration(absSrcPath, symbol, absSrcPath));
+        }
+      });
+
+  return staticSymbols;
+}

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

@@ -10,28 +10,32 @@
 
 /**
  * Extract i18n messages from source code
- *
- * TODO(vicb): factorize code with the CodeGenerator
  */
 // Must be imported first, because angular2 decorators throws on load.
 import 'reflect-metadata';
 
 import * as compiler from '@angular/compiler';
-import {Component, NgModule, ViewEncapsulation} from '@angular/core';
+import * as tsc from '@angular/tsc-wrapped';
 import * as path from 'path';
 import * as ts from 'typescript';
-import * as tsc from '@angular/tsc-wrapped';
-import {CompileMetadataResolver, DirectiveNormalizer, DomElementSchemaRegistry, HtmlParser, Lexer, NgModuleCompiler, Parser, StyleCompiler, TemplateParser, TypeScriptEmitter, ViewCompiler, ParseError} from './private_import_compiler';
-import {Console} from './private_import_core';
-import {ReflectorHost, ReflectorHostContext} from './reflector_host';
-import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
-import {StaticReflector, StaticSymbol} from './static_reflector';
+
+import {Extractor} from './extractor';
 
 function extract(
     ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.I18nExtractionCliOptions,
     program: ts.Program, host: ts.CompilerHost) {
-  const htmlParser = new compiler.I18NHtmlParser(new HtmlParser());
-  const extractor = Extractor.create(ngOptions, cliOptions.i18nFormat, program, host, htmlParser);
+  const resourceLoader: compiler.ResourceLoader = {
+    get: (s: string) => {
+      if (!host.fileExists(s)) {
+        // TODO: We should really have a test for error cases like this!
+        throw new Error(`Compilation failed. Resource file not found: ${s}`);
+      }
+      return Promise.resolve(host.readFile(s));
+    }
+  };
+  const extractor =
+      Extractor.create(ngOptions, cliOptions.i18nFormat, program, host, resourceLoader);
+
   const bundlePromise: Promise<compiler.MessageBundle> = extractor.extract();
 
   return (bundlePromise).then(messageBundle => {
@@ -47,6 +51,7 @@ function extract(
       case 'xliff':
       case 'xlf':
       default:
+        const htmlParser = new compiler.I18NHtmlParser(new compiler.HtmlParser());
         ext = 'xlf';
         serializer = new compiler.Xliff(htmlParser, compiler.DEFAULT_INTERPOLATION_CONFIG);
         break;
@@ -57,146 +62,6 @@ function extract(
   });
 }
 
-const GENERATED_FILES = /\.ngfactory\.ts$|\.css\.ts$|\.css\.shim\.ts$/;
-
-export class Extractor {
-  constructor(
-      private program: ts.Program, public host: ts.CompilerHost,
-      private staticReflector: StaticReflector, private messageBundle: compiler.MessageBundle,
-      private reflectorHost: ReflectorHost, private metadataResolver: CompileMetadataResolver,
-      private directiveNormalizer: DirectiveNormalizer,
-      private compiler: compiler.OfflineCompiler) {}
-
-  private readFileMetadata(absSourcePath: string): FileMetadata {
-    const moduleMetadata = this.staticReflector.getModuleMetadata(absSourcePath);
-    const result: FileMetadata = {components: [], ngModules: [], fileUrl: absSourcePath};
-    if (!moduleMetadata) {
-      console.log(`WARNING: no metadata found for ${absSourcePath}`);
-      return result;
-    }
-    const metadata = moduleMetadata['metadata'];
-    const symbols = metadata && Object.keys(metadata);
-    if (!symbols || !symbols.length) {
-      return result;
-    }
-    for (const symbol of symbols) {
-      if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
-        // Ignore symbols that are only included to record error information.
-        continue;
-      }
-      const staticType = this.reflectorHost.findDeclaration(absSourcePath, symbol, absSourcePath);
-      const annotations = this.staticReflector.annotations(staticType);
-      annotations.forEach((annotation) => {
-        if (annotation instanceof NgModule) {
-          result.ngModules.push(staticType);
-        } else if (annotation instanceof Component) {
-          result.components.push(staticType);
-        }
-      });
-    }
-    return result;
-  }
-
-  extract(): Promise<compiler.MessageBundle> {
-    const filePaths =
-        this.program.getSourceFiles().map(sf => sf.fileName).filter(f => !GENERATED_FILES.test(f));
-    const fileMetas = filePaths.map((filePath) => this.readFileMetadata(filePath));
-    const ngModules = fileMetas.reduce((ngModules, fileMeta) => {
-      ngModules.push(...fileMeta.ngModules);
-      return ngModules;
-    }, <StaticSymbol[]>[]);
-    const analyzedNgModules = this.compiler.analyzeModules(ngModules);
-    const errors: ParseError[] = [];
-
-    let bundlePromise =
-        Promise
-            .all(fileMetas.map((fileMeta) => {
-              const url = fileMeta.fileUrl;
-              return Promise.all(fileMeta.components.map(compType => {
-                const compMeta = this.metadataResolver.getDirectiveMetadata(<any>compType);
-                const ngModule = analyzedNgModules.ngModuleByComponent.get(compType);
-                if (!ngModule) {
-                  throw new Error(
-                      `Cannot determine the module for component ${compMeta.type.name}!`);
-                }
-                return Promise
-                    .all([compMeta, ...ngModule.transitiveModule.directives].map(
-                        dirMeta =>
-                            this.directiveNormalizer.normalizeDirective(dirMeta).asyncResult))
-                    .then((normalizedCompWithDirectives) => {
-                      const compMeta = normalizedCompWithDirectives[0];
-                      const html = compMeta.template.template;
-                      const interpolationConfig =
-                          compiler.InterpolationConfig.fromArray(compMeta.template.interpolation);
-                      errors.push(
-                          ...this.messageBundle.updateFromTemplate(html, url, interpolationConfig));
-                    });
-              }));
-            }))
-            .then(_ => this.messageBundle);
-
-    if (errors.length) {
-      throw new Error(errors.map(e => e.toString()).join('\n'));
-    }
-
-    return bundlePromise;
-  }
-
-  static create(
-      options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
-      compilerHost: ts.CompilerHost, htmlParser: compiler.I18NHtmlParser,
-      reflectorHostContext?: ReflectorHostContext): Extractor {
-    const resourceLoader: compiler.ResourceLoader = {
-      get: (s: string) => {
-        if (!compilerHost.fileExists(s)) {
-          // TODO: We should really have a test for error cases like this!
-          throw new Error(`Compilation failed. Resource file not found: ${s}`);
-        }
-        return Promise.resolve(compilerHost.readFile(s));
-      }
-    };
-
-    const urlResolver: compiler.UrlResolver = compiler.createOfflineCompileUrlResolver();
-    const reflectorHost = new ReflectorHost(program, compilerHost, options, reflectorHostContext);
-    const staticReflector = new StaticReflector(reflectorHost);
-    StaticAndDynamicReflectionCapabilities.install(staticReflector);
-
-    const config = new compiler.CompilerConfig({
-      genDebugInfo: options.debug === true,
-      defaultEncapsulation: ViewEncapsulation.Emulated,
-      logBindingUpdate: false,
-      useJit: false
-    });
-
-    const normalizer = new DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
-    const expressionParser = new Parser(new Lexer());
-    const elementSchemaRegistry = new DomElementSchemaRegistry();
-    const console = new Console();
-    const tmplParser =
-        new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
-    const resolver = new CompileMetadataResolver(
-        new compiler.NgModuleResolver(staticReflector),
-        new compiler.DirectiveResolver(staticReflector), new compiler.PipeResolver(staticReflector),
-        elementSchemaRegistry, staticReflector);
-    const offlineCompiler = new compiler.OfflineCompiler(
-        resolver, normalizer, tmplParser, new StyleCompiler(urlResolver), new ViewCompiler(config),
-        new NgModuleCompiler(), new TypeScriptEmitter(reflectorHost), null, null);
-
-    // TODO(vicb): implicit tags & attributes
-    let messageBundle = new compiler.MessageBundle(htmlParser, [], {});
-
-    return new Extractor(
-        program, compilerHost, staticReflector, messageBundle, reflectorHost, resolver, normalizer,
-        offlineCompiler);
-  }
-}
-
-interface FileMetadata {
-  fileUrl: string;
-  components: StaticSymbol[];
-  ngModules: StaticSymbol[];
-}
-
 // Entry point
 if (require.main === module) {
   const args = require('minimist')(process.argv.slice(2));

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

@@ -0,0 +1,110 @@
+/**
+ * @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
+ */
+
+
+/**
+ * Extract i18n messages from source code
+ */
+// Must be imported first, because angular2 decorators throws on load.
+import 'reflect-metadata';
+
+import * as compiler from '@angular/compiler';
+import {ViewEncapsulation} from '@angular/core';
+import * as tsc from '@angular/tsc-wrapped';
+import * as ts from 'typescript';
+
+import {extractProgramSymbols} from './codegen';
+import {ReflectorHost} from './reflector_host';
+import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
+import {StaticReflector, StaticSymbol} from './static_reflector';
+
+export class Extractor {
+  constructor(
+      private options: tsc.AngularCompilerOptions, private program: ts.Program,
+      public host: ts.CompilerHost, private staticReflector: StaticReflector,
+      private messageBundle: compiler.MessageBundle, private reflectorHost: ReflectorHost,
+      private metadataResolver: compiler.CompileMetadataResolver,
+      private directiveNormalizer: compiler.DirectiveNormalizer) {}
+
+  extract(): Promise<compiler.MessageBundle> {
+    const programSymbols: StaticSymbol[] =
+        extractProgramSymbols(this.program, this.staticReflector, this.reflectorHost, this.options);
+
+    const files =
+        compiler.analyzeNgModules(programSymbols, {transitiveModules: true}, this.metadataResolver)
+            .files;
+    const errors: compiler.ParseError[] = [];
+    const filePromises: Promise<any>[] = [];
+
+    files.forEach(file => {
+      const cmpPromises: Promise<compiler.CompileDirectiveMetadata>[] = [];
+      file.directives.forEach(directiveType => {
+        const dirMeta = this.metadataResolver.getDirectiveMetadata(directiveType);
+        if (dirMeta.isComponent) {
+          cmpPromises.push(this.directiveNormalizer.normalizeDirective(dirMeta).asyncResult);
+        }
+      });
+
+      if (cmpPromises.length) {
+        const done =
+            Promise.all(cmpPromises).then((compMetas: compiler.CompileDirectiveMetadata[]) => {
+              compMetas.forEach(compMeta => {
+                const html = compMeta.template.template;
+                const interpolationConfig =
+                    compiler.InterpolationConfig.fromArray(compMeta.template.interpolation);
+                errors.push(...this.messageBundle.updateFromTemplate(
+                    html, file.srcUrl, interpolationConfig));
+              });
+            });
+
+        filePromises.push(done);
+      }
+    });
+
+
+    if (errors.length) {
+      throw new Error(errors.map(e => e.toString()).join('\n'));
+    }
+
+    return Promise.all(filePromises).then(_ => this.messageBundle);
+  }
+
+  static create(
+      options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
+      compilerHost: ts.CompilerHost, resourceLoader: compiler.ResourceLoader,
+      reflectorHost?: ReflectorHost): Extractor {
+    const htmlParser = new compiler.I18NHtmlParser(new compiler.HtmlParser());
+
+    const urlResolver: compiler.UrlResolver = compiler.createOfflineCompileUrlResolver();
+    if (!reflectorHost) reflectorHost = new ReflectorHost(program, compilerHost, options);
+    const staticReflector = new StaticReflector(reflectorHost);
+    StaticAndDynamicReflectionCapabilities.install(staticReflector);
+
+    const config = new compiler.CompilerConfig({
+      genDebugInfo: options.debug === true,
+      defaultEncapsulation: ViewEncapsulation.Emulated,
+      logBindingUpdate: false,
+      useJit: false
+    });
+
+    const normalizer =
+        new compiler.DirectiveNormalizer(resourceLoader, urlResolver, htmlParser, config);
+    const elementSchemaRegistry = new compiler.DomElementSchemaRegistry();
+    const resolver = new compiler.CompileMetadataResolver(
+        new compiler.NgModuleResolver(staticReflector),
+        new compiler.DirectiveResolver(staticReflector), new compiler.PipeResolver(staticReflector),
+        elementSchemaRegistry, staticReflector);
+
+    // TODO(vicb): implicit tags & attributes
+    let messageBundle = new compiler.MessageBundle(htmlParser, [], {});
+
+    return new Extractor(
+        options, program, compilerHost, staticReflector, messageBundle, reflectorHost, resolver,
+        normalizer);
+  }
+}

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

@@ -19,7 +19,9 @@ import {CodeGenerator} from './codegen';
 function codegen(
     ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.NgcCliOptions, program: ts.Program,
     host: ts.CompilerHost) {
-  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen();
+  return CodeGenerator.create(ngOptions, cliOptions, program, host).codegen({
+    transitiveModules: true
+  });
 }
 
 // CLI entry point

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

@@ -1,54 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {__compiler_private__ as _} from '@angular/compiler';
-
-export type AssetUrl = typeof _._AssetUrl;
-export var AssetUrl: typeof _.AssetUrl = _.AssetUrl;
-
-export type ImportGenerator = typeof _._ImportGenerator;
-export var ImportGenerator: typeof _.ImportGenerator = _.ImportGenerator;
-
-export type CompileMetadataResolver = typeof _._CompileMetadataResolver;
-export var CompileMetadataResolver: typeof _.CompileMetadataResolver = _.CompileMetadataResolver;
-
-export type HtmlParser = typeof _._HtmlParser;
-export var HtmlParser: typeof _.HtmlParser = _.HtmlParser;
-
-export type ParseError = typeof _._ParseError;
-export var ParseError: typeof _.ParseError = _.ParseError;
-
-export type InterpolationConfig = typeof _._InterpolationConfig;
-export var InterpolationConfig: typeof _.InterpolationConfig = _.InterpolationConfig;
-
-export type DirectiveNormalizer = typeof _._DirectiveNormalizer;
-export var DirectiveNormalizer: typeof _.DirectiveNormalizer = _.DirectiveNormalizer;
-
-export type Lexer = typeof _._Lexer;
-export var Lexer: typeof _.Lexer = _.Lexer;
-
-export type Parser = typeof _._Parser;
-export var Parser: typeof _.Parser = _.Parser;
-
-export type TemplateParser = typeof _._TemplateParser;
-export var TemplateParser: typeof _.TemplateParser = _.TemplateParser;
-
-export type DomElementSchemaRegistry = typeof _._DomElementSchemaRegistry;
-export var DomElementSchemaRegistry: typeof _.DomElementSchemaRegistry = _.DomElementSchemaRegistry;
-
-export type StyleCompiler = typeof _._StyleCompiler;
-export var StyleCompiler: typeof _.StyleCompiler = _.StyleCompiler;
-
-export type ViewCompiler = typeof _._ViewCompiler;
-export var ViewCompiler: typeof _.ViewCompiler = _.ViewCompiler;
-
-export type NgModuleCompiler = typeof _._NgModuleCompiler;
-export var NgModuleCompiler: typeof _.NgModuleCompiler = _.NgModuleCompiler;
-
-export type TypeScriptEmitter = typeof _._TypeScriptEmitter;
-export var TypeScriptEmitter: typeof _.TypeScriptEmitter = _.TypeScriptEmitter;

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

@@ -6,12 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {AssetUrl, ImportGenerator} from '@angular/compiler';
 import {AngularCompilerOptions, MetadataCollector, ModuleMetadata} from '@angular/tsc-wrapped';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {AssetUrl, ImportGenerator} from './private_import_compiler';
 import {StaticReflectorHost, StaticSymbol} from './static_reflector';
 
 const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
@@ -250,6 +250,12 @@ export class ReflectorHost implements StaticReflectorHost, ImportGenerator {
     } else {
       const sf = this.program.getSourceFile(filePath);
       if (!sf) {
+        if (this.context.fileExists(filePath)) {
+          const sourceText = this.context.readFile(filePath);
+          return this.metadataCollector.getMetadata(
+              ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true));
+        }
+
         throw new Error(`Source file ${filePath} not present in program.`);
       }
       return this.metadataCollector.getMetadata(sf);

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

@@ -25,7 +25,7 @@ export interface StaticReflectorHost {
    * @param modulePath is a string identifier for a module as an absolute path.
    * @returns the metadata for the given module.
    */
-  getMetadataFor(modulePath: string): {[key: string]: any};
+  getMetadataFor(modulePath: string): {[key: string]: any}|{[key: string]: any}[];
 
   /**
    * Resolve a symbol from an import statement form, to the file where it is declared.
@@ -72,13 +72,12 @@ export class StaticReflector implements ReflectorReader {
   constructor(private host: StaticReflectorHost) { this.initializeConversionMap(); }
 
   importUri(typeOrFunc: StaticSymbol): string {
-    var staticSymbol = this.host.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
+    const staticSymbol = this.host.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
     return staticSymbol ? staticSymbol.filePath : null;
   }
 
   resolveIdentifier(name: string, moduleUrl: string, runtime: any): any {
-    const result = this.host.findDeclaration(moduleUrl, name, '');
-    return result;
+    return this.host.findDeclaration(moduleUrl, name, '');
   }
 
   resolveEnum(enumIdentifier: any, name: string): any {
@@ -238,9 +237,9 @@ export class StaticReflector implements ReflectorReader {
 
   /** @internal */
   public simplify(context: StaticSymbol, value: any): any {
-    let _this = this;
+    const _this = this;
     let scope = BindingScope.empty;
-    let calling = new Map<StaticSymbol, boolean>();
+    const calling = new Map<StaticSymbol, boolean>();
 
     function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
       function resolveReference(context: StaticSymbol, expression: any): StaticSymbol {
@@ -255,16 +254,15 @@ export class StaticReflector implements ReflectorReader {
       }
 
       function resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        let result: any = staticSymbol;
-        let moduleMetadata = _this.getModuleMetadata(staticSymbol.filePath);
-        let declarationValue =
+        const moduleMetadata = _this.getModuleMetadata(staticSymbol.filePath);
+        const declarationValue =
             moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
         return declarationValue;
       }
 
       function isOpaqueToken(context: StaticSymbol, value: any): boolean {
         if (value && value.__symbolic === 'new' && value.expression) {
-          let target = value.expression;
+          const target = value.expression;
           if (target.__symbolic == 'reference') {
             return sameSymbol(resolveReference(context, target), _this.opaqueToken);
           }
@@ -535,7 +533,7 @@ export class StaticReflector implements ReflectorReader {
       }
     }
 
-    let result = simplifyInContext(context, value, 0);
+    const result = simplifyInContext(context, value, 0);
     if (shouldIgnore(result)) {
       return undefined;
     }
@@ -550,8 +548,7 @@ export class StaticReflector implements ReflectorReader {
     if (!moduleMetadata) {
       moduleMetadata = this.host.getMetadataFor(module);
       if (Array.isArray(moduleMetadata)) {
-        moduleMetadata = (<Array<any>>moduleMetadata)
-                             .find(element => element.version === SUPPORTED_SCHEMA_VERSION) ||
+        moduleMetadata = moduleMetadata.find(md => md['version'] === SUPPORTED_SCHEMA_VERSION) ||
             moduleMetadata[0];
       }
       if (!moduleMetadata) {
@@ -568,12 +565,8 @@ export class StaticReflector implements ReflectorReader {
   }
 
   private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
-    let moduleMetadata = this.getModuleMetadata(type.filePath);
-    let result = moduleMetadata['metadata'][type.name];
-    if (!result) {
-      result = {__symbolic: 'class'};
-    }
-    return result;
+    const moduleMetadata = this.getModuleMetadata(type.filePath);
+    return moduleMetadata['metadata'][type.name] || {__symbolic: 'class'};
   }
 }
 
@@ -613,7 +606,7 @@ function produceErrorMessage(error: any): string {
 function mapStringMap(input: {[key: string]: any}, transform: (value: any, key: string) => any):
     {[key: string]: any} {
   if (!input) return {};
-  var result: {[key: string]: any} = {};
+  const result: {[key: string]: any} = {};
   Object.keys(input).forEach((key) => {
     let value = transform(input[key], key);
     if (!shouldIgnore(value)) {
@@ -638,8 +631,7 @@ abstract class BindingScope {
   public static empty: BindingScope = {resolve: name => BindingScope.missing};
 
   public static build(): BindingScopeBuilder {
-    let current = new Map<string, any>();
-    let parent: BindingScope = undefined;
+    const current = new Map<string, any>();
     return {
       define: function(name, value) {
         current.set(name, value);

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

@@ -8,7 +8,6 @@
 
 import {StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler-cli/src/static_reflector';
 import {HostListener, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
-import {ListWrapper} from '@angular/facade/src/collection';
 import {MetadataCollector} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';
 
@@ -474,7 +473,7 @@ class MockReflectorHost implements StaticReflectorHost {
 
     function resolvePath(pathParts: string[]): string {
       let result: string[] = [];
-      ListWrapper.forEachWithIndex(pathParts, (part, index) => {
+      pathParts.forEach((part, index) => {
         switch (part) {
           case '':
           case '.':

modules/@angular/compiler/index.ts

@@ -21,6 +21,36 @@
  *   </p>
  * </div>
  */
-export * from './src/index';
+export * from './src/template_parser/template_ast';
+export {TEMPLATE_TRANSFORMS} from './src/template_parser/template_parser';
+export {CompilerConfig, RenderTypes} from './src/config';
+export * from './src/compile_metadata';
+export * from './src/offline_compiler';
+export {RuntimeCompiler} from './src/runtime_compiler';
+export * from './src/url_resolver';
+export * from './src/resource_loader';
+export * from './src/compiler';
+export {DirectiveResolver} from './src/directive_resolver';
+export {PipeResolver} from './src/pipe_resolver';
+export {NgModuleResolver} from './src/ng_module_resolver';
+export {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './src/ml_parser/interpolation_config';
+export * from './src/schema/element_schema_registry';
+export * from './src/i18n/index';
+export * from './src/directive_normalizer';
+export * from './src/expression_parser/lexer';
+export * from './src/expression_parser/parser';
+export * from './src/metadata_resolver';
+export * from './src/ml_parser/html_parser';
+export * from './src/ml_parser/interpolation_config';
+export {NgModuleCompiler} from './src/ng_module_compiler';
+export {DirectiveWrapperCompiler} from './src/directive_wrapper_compiler';
+export * from './src/output/path_util';
+export * from './src/output/ts_emitter';
+export * from './src/parse_util';
+export * from './src/schema/dom_element_schema_registry';
+export * from './src/selector';
+export * from './src/style_compiler';
+export * from './src/template_parser/template_parser';
+export {ViewCompiler} from './src/view_compiler/view_compiler';
 
 // This file only reexports content of the `src` folder. Keep it that way.

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

@@ -7,9 +7,8 @@
  */
 
 import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata} from '../compile_metadata';
-import {ListWrapper, StringMapWrapper} from '../facade/collection';
-import {isArray, isBlank, isPresent, isString, isStringMap} from '../facade/lang';
-import {Math} from '../facade/math';
+import {StringMapWrapper} from '../facade/collection';
+import {isBlank, isPresent} from '../facade/lang';
 import {ParseError} from '../parse_util';
 import {ANY_STATE, FILL_STYLE_FLAG} from '../private_import_core';
 
@@ -97,7 +96,7 @@ function _parseAnimationDeclarationStates(
   var styleValues: Styles[] = [];
   stateMetadata.styles.styles.forEach(stylesEntry => {
     // TODO (matsko): change this when we get CSS class integration support
-    if (isStringMap(stylesEntry)) {
+    if (typeof stylesEntry === 'object' && stylesEntry !== null) {
       styleValues.push(stylesEntry as Styles);
     } else {
       errors.push(new AnimationParseError(
@@ -172,8 +171,7 @@ function _parseAnimationTransitionExpr(
 
 function _normalizeAnimationEntry(entry: CompileAnimationMetadata | CompileAnimationMetadata[]):
     CompileAnimationMetadata {
-  return isArray(entry) ? new CompileAnimationSequenceMetadata(<CompileAnimationMetadata[]>entry) :
-                          <CompileAnimationMetadata>entry;
+  return Array.isArray(entry) ? new CompileAnimationSequenceMetadata(entry) : entry;
 }
 
 function _normalizeStyleMetadata(
@@ -181,9 +179,8 @@ function _normalizeStyleMetadata(
     errors: AnimationParseError[]): {[key: string]: string | number}[] {
   var normalizedStyles: {[key: string]: string | number}[] = [];
   entry.styles.forEach(styleEntry => {
-    if (isString(styleEntry)) {
-      ListWrapper.addAll(
-          normalizedStyles, _resolveStylesFromState(<string>styleEntry, stateStyles, errors));
+    if (typeof styleEntry === 'string') {
+      normalizedStyles.push(..._resolveStylesFromState(<string>styleEntry, stateStyles, errors));
     } else {
       normalizedStyles.push(<{[key: string]: string | number}>styleEntry);
     }
@@ -202,10 +199,10 @@ function _normalizeStyleSteps(
 
 function _mergeAnimationStyles(
     stylesList: any[], newItem: {[key: string]: string | number} | string) {
-  if (isStringMap(newItem) && stylesList.length > 0) {
+  if (typeof newItem === 'object' && newItem !== null && stylesList.length > 0) {
     var lastIndex = stylesList.length - 1;
     var lastItem = stylesList[lastIndex];
-    if (isStringMap(lastItem)) {
+    if (typeof lastItem === 'object' && lastItem !== null) {
       stylesList[lastIndex] = StringMapWrapper.merge(
           <{[key: string]: string | number}>lastItem, <{[key: string]: string | number}>newItem);
       return;
@@ -292,7 +289,7 @@ function _resolveStylesFromState(
           `Unable to apply styles due to missing a state: "${normalizedStateName}"`));
     } else {
       value.styles.forEach(stylesEntry => {
-        if (isStringMap(stylesEntry)) {
+        if (typeof stylesEntry === 'object' && stylesEntry !== null) {
           styles.push(stylesEntry as Styles);
         }
       });
@@ -348,12 +345,12 @@ function _parseAnimationKeyframes(
   });
 
   if (doSortKeyframes) {
-    ListWrapper.sort(rawKeyframes, (a, b) => a[0] <= b[0] ? -1 : 1);
+    rawKeyframes.sort((a, b) => a[0] <= b[0] ? -1 : 1);
   }
 
   var firstKeyframe = rawKeyframes[0];
   if (firstKeyframe[0] != _INITIAL_KEYFRAME) {
-    ListWrapper.insert(rawKeyframes, 0, firstKeyframe = [_INITIAL_KEYFRAME, {}]);
+    rawKeyframes.splice(0, 0, firstKeyframe = [_INITIAL_KEYFRAME, {}]);
   }
 
   var firstKeyframeStyles = firstKeyframe[1];
@@ -423,7 +420,7 @@ function _parseTransitionAnimation(
           steps.push(new AnimationStepAst(startingStyles, [], 0, 0, ''));
         } else {
           var innerStep = <AnimationStepAst>innerAst;
-          ListWrapper.addAll(innerStep.startingStyles.styles, previousStyles);
+          innerStep.startingStyles.styles.push(...previousStyles);
         }
         previousStyles = null;
       }
@@ -504,7 +501,7 @@ function _parseTimeExpression(
   var duration: number;
   var delay: number = 0;
   var easing: string = null;
-  if (isString(exp)) {
+  if (typeof exp === 'string') {
     const matches = exp.match(regex);
     if (matches === null) {
       errors.push(new AnimationParseError(`The provided timing value "${exp}" is invalid.`));

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

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ListWrapper} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 
 export class StylesCollectionEntry {
@@ -37,7 +36,7 @@ export class StylesCollection {
       }
     }
 
-    ListWrapper.insert(entries, insertionIndex, tuple);
+    entries.splice(insertionIndex, 0, tuple);
   }
 
   getByIndex(property: string, index: number): StylesCollectionEntry {

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

@@ -8,17 +8,17 @@
 
 import {isDevMode} from '@angular/core';
 
-import {isArray, isBlank, isPresent, isString} from '../src/facade/lang';
+import {isBlank, isPresent} from '../src/facade/lang';
 
 export function assertArrayOfStrings(identifier: string, value: any) {
   if (!isDevMode() || isBlank(value)) {
     return;
   }
-  if (!isArray(value)) {
+  if (!Array.isArray(value)) {
     throw new Error(`Expected '${identifier}' to be an array of strings.`);
   }
   for (var i = 0; i < value.length; i += 1) {
-    if (!isString(value[i])) {
+    if (typeof value[i] !== 'string') {
       throw new Error(`Expected '${identifier}' to be an array of strings.`);
     }
   }
@@ -33,7 +33,7 @@ const INTERPOLATION_BLACKLIST_REGEXPS = [
 ];
 
 export function assertInterpolationSymbols(identifier: string, value: any): void {
-  if (isPresent(value) && !(isArray(value) && value.length == 2)) {
+  if (isPresent(value) && !(Array.isArray(value) && value.length == 2)) {
     throw new Error(`Expected '${identifier}' to be an array, [start, end].`);
   } else if (isDevMode() && !isBlank(value)) {
     const start = value[0] as string;

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

@@ -9,7 +9,7 @@
 import {ChangeDetectionStrategy, SchemaMetadata, Type, ViewEncapsulation} from '@angular/core';
 
 import {ListWrapper, MapWrapper} from './facade/collection';
-import {isPresent, isStringMap, normalizeBlank, normalizeBool} from './facade/lang';
+import {isPresent} from './facade/lang';
 import {LifecycleHooks} from './private_import_core';
 import {CssSelector} from './selector';
 import {sanitizeIdentifier, splitAtColon} from './util';
@@ -23,7 +23,6 @@ function unimplemented(): any {
 // group 2: "event" from "(event)"
 // group 3: "@trigger" from "@trigger"
 const HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/;
-const UNDEFINED = new Object();
 
 export abstract class CompileMetadataWithIdentifier {
   get identifier(): CompileIdentifierMetadata { return <CompileIdentifierMetadata>unimplemented(); }
@@ -125,12 +124,12 @@ export class CompileDiDependencyMetadata {
         token?: CompileTokenMetadata,
         value?: any
       } = {}) {
-    this.isAttribute = normalizeBool(isAttribute);
-    this.isSelf = normalizeBool(isSelf);
-    this.isHost = normalizeBool(isHost);
-    this.isSkipSelf = normalizeBool(isSkipSelf);
-    this.isOptional = normalizeBool(isOptional);
-    this.isValue = normalizeBool(isValue);
+    this.isAttribute = !!isAttribute;
+    this.isSelf = !!isSelf;
+    this.isHost = !!isHost;
+    this.isSkipSelf = !!isSkipSelf;
+    this.isOptional = !!isOptional;
+    this.isValue = !!isValue;
     this.query = query;
     this.viewQuery = viewQuery;
     this.token = token;
@@ -161,8 +160,8 @@ export class CompileProviderMetadata {
     this.useValue = useValue;
     this.useExisting = useExisting;
     this.useFactory = useFactory;
-    this.deps = normalizeBlank(deps);
-    this.multi = normalizeBool(multi);
+    this.deps = deps || null;
+    this.multi = !!multi;
   }
 }
 
@@ -192,7 +191,7 @@ export class CompileTokenMetadata implements CompileMetadataWithIdentifier {
           {value?: any, identifier?: CompileIdentifierMetadata, identifierIsInstance?: boolean}) {
     this.value = value;
     this.identifier = identifier;
-    this.identifierIsInstance = normalizeBool(identifierIsInstance);
+    this.identifierIsInstance = !!identifierIsInstance;
   }
 
   get reference(): any {
@@ -227,7 +226,7 @@ export class CompileTypeMetadata extends CompileIdentifierMetadata {
     lifecycleHooks?: LifecycleHooks[];
   } = {}) {
     super({reference: reference, name: name, moduleUrl: moduleUrl, prefix: prefix, value: value});
-    this.isHost = normalizeBool(isHost);
+    this.isHost = !!isHost;
     this.diDeps = _normalizeArray(diDeps);
     this.lifecycleHooks = _normalizeArray(lifecycleHooks);
   }
@@ -248,8 +247,8 @@ export class CompileQueryMetadata {
     read?: CompileTokenMetadata
   } = {}) {
     this.selectors = selectors;
-    this.descendants = normalizeBool(descendants);
-    this.first = normalizeBool(first);
+    this.descendants = !!descendants;
+    this.first = !!first;
     this.propertyName = propertyName;
     this.read = read;
   }
@@ -303,9 +302,9 @@ export class CompileTemplateMetadata {
     this.styles = _normalizeArray(styles);
     this.styleUrls = _normalizeArray(styleUrls);
     this.externalStylesheets = _normalizeArray(externalStylesheets);
-    this.animations = isPresent(animations) ? ListWrapper.flatten(animations) : [];
+    this.animations = animations ? ListWrapper.flatten(animations) : [];
     this.ngContentSelectors = ngContentSelectors || [];
-    if (isPresent(interpolation) && interpolation.length != 2) {
+    if (interpolation && interpolation.length != 2) {
       throw new Error(`'interpolation' should have a start and an end symbol.`);
     }
     this.interpolation = interpolation;
@@ -375,7 +374,7 @@ export class CompileDirectiveMetadata implements CompileMetadataWithIdentifier {
 
     return new CompileDirectiveMetadata({
       type,
-      isComponent: normalizeBool(isComponent), selector, exportAs, changeDetection,
+      isComponent: !!isComponent, selector, exportAs, changeDetection,
       inputs: inputsMap,
       outputs: outputsMap,
       hostListeners,
@@ -503,13 +502,13 @@ export class CompilePipeMetadata implements CompileMetadataWithIdentifier {
   } = {}) {
     this.type = type;
     this.name = name;
-    this.pure = normalizeBool(pure);
+    this.pure = !!pure;
   }
   get identifier(): CompileIdentifierMetadata { return this.type; }
 }
 
 /**
- * Metadata regarding compilation of a directive.
+ * Metadata regarding compilation of a module.
  */
 export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
   type: CompileTypeMetadata;
@@ -569,6 +568,7 @@ export class CompileNgModuleMetadata implements CompileMetadataWithIdentifier {
 export class TransitiveCompileNgModuleMetadata {
   directivesSet = new Set<Type<any>>();
   pipesSet = new Set<Type<any>>();
+
   constructor(
       public modules: CompileNgModuleMetadata[], public providers: CompileProviderMetadata[],
       public entryComponents: CompileTypeMetadata[], public directives: CompileDirectiveMetadata[],
@@ -581,11 +581,13 @@ export class TransitiveCompileNgModuleMetadata {
 export function removeIdentifierDuplicates<T extends CompileMetadataWithIdentifier>(items: T[]):
     T[] {
   const map = new Map<any, T>();
+
   items.forEach((item) => {
     if (!map.get(item.identifier.reference)) {
       map.set(item.identifier.reference, item);
     }
   });
+
   return MapWrapper.values(map);
 }
 
@@ -594,7 +596,7 @@ function _normalizeArray(obj: any[]): any[] {
 }
 
 export function isStaticSymbol(value: any): value is StaticSymbol {
-  return isStringMap(value) && isPresent(value['name']) && isPresent(value['filePath']);
+  return typeof value === 'object' && value !== null && value['name'] && value['filePath'];
 }
 
 export interface StaticSymbol {

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

@@ -8,39 +8,27 @@
 
 import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Injectable, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
 
-export * from './template_parser/template_ast';
-export {TEMPLATE_TRANSFORMS} from './template_parser/template_parser';
-export {CompilerConfig, RenderTypes} from './config';
-export * from './compile_metadata';
-export * from './offline_compiler';
-export {RuntimeCompiler} from './runtime_compiler';
-export * from './url_resolver';
-export * from './resource_loader';
-
-export {DirectiveResolver} from './directive_resolver';
-export {PipeResolver} from './pipe_resolver';
-export {NgModuleResolver} from './ng_module_resolver';
-
-import {TemplateParser} from './template_parser/template_parser';
-import {HtmlParser} from './ml_parser/html_parser';
-import {DirectiveNormalizer} from './directive_normalizer';
-import {CompileMetadataResolver} from './metadata_resolver';
-import {StyleCompiler} from './style_compiler';
-import {ViewCompiler} from './view_compiler/view_compiler';
-import {NgModuleCompiler} from './ng_module_compiler';
 import {CompilerConfig} from './config';
-import {RuntimeCompiler} from './runtime_compiler';
-import {ElementSchemaRegistry} from './schema/element_schema_registry';
-import {DomElementSchemaRegistry} from './schema/dom_element_schema_registry';
-import {UrlResolver, DEFAULT_PACKAGE_URL_PROVIDER} from './url_resolver';
-import {Parser} from './expression_parser/parser';
-import {Lexer} from './expression_parser/lexer';
+import {DirectiveNormalizer} from './directive_normalizer';
 import {DirectiveResolver} from './directive_resolver';
-import {PipeResolver} from './pipe_resolver';
-import {NgModuleResolver} from './ng_module_resolver';
-import {Console, Reflector, reflector, ReflectorReader, ReflectionCapabilities} from './private_import_core';
-import {ResourceLoader} from './resource_loader';
+import {DirectiveWrapperCompiler} from './directive_wrapper_compiler';
+import {Lexer} from './expression_parser/lexer';
+import {Parser} from './expression_parser/parser';
 import * as i18n from './i18n/index';
+import {CompileMetadataResolver} from './metadata_resolver';
+import {HtmlParser} from './ml_parser/html_parser';
+import {NgModuleCompiler} from './ng_module_compiler';
+import {NgModuleResolver} from './ng_module_resolver';
+import {PipeResolver} from './pipe_resolver';
+import {Console, ReflectionCapabilities, Reflector, ReflectorReader, reflector} from './private_import_core';
+import {ResourceLoader} from './resource_loader';
+import {RuntimeCompiler} from './runtime_compiler';
+import {DomElementSchemaRegistry} from './schema/dom_element_schema_registry';
+import {ElementSchemaRegistry} from './schema/element_schema_registry';
+import {StyleCompiler} from './style_compiler';
+import {TemplateParser} from './template_parser/template_parser';
+import {DEFAULT_PACKAGE_URL_PROVIDER, UrlResolver} from './url_resolver';
+import {ViewCompiler} from './view_compiler/view_compiler';
 
 const _NO_RESOURCE_LOADER: ResourceLoader = {
   get(url: string): Promise<string>{
@@ -77,6 +65,7 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
   StyleCompiler,
   ViewCompiler,
   NgModuleCompiler,
+  DirectiveWrapperCompiler,
   {provide: CompilerConfig, useValue: new CompilerConfig()},
   RuntimeCompiler,
   {provide: Compiler, useExisting: RuntimeCompiler},

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

@@ -0,0 +1,48 @@
+/**
+ * @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 {Identifiers, resolveIdentifier} from '../identifiers';
+import {ClassBuilder} from '../output/class_builder';
+import * as o from '../output/output_ast';
+
+import {ConvertPropertyBindingResult} from './expression_converter';
+
+export class CheckBindingField {
+  constructor(public expression: o.ReadPropExpr, public bindingId: string) {}
+}
+
+export function createCheckBindingField(builder: ClassBuilder): CheckBindingField {
+  const bindingId = `${builder.fields.length}`;
+  const fieldExpr = createBindFieldExpr(bindingId);
+  // private is fine here as no child view will reference the cached value...
+  builder.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
+  builder.ctorStmts.push(o.THIS_EXPR.prop(fieldExpr.name)
+                             .set(o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED)))
+                             .toStmt());
+  return new CheckBindingField(fieldExpr, bindingId);
+}
+
+export function createCheckBindingStmt(
+    evalResult: ConvertPropertyBindingResult, fieldExpr: o.ReadPropExpr,
+    throwOnChangeVar: o.Expression, actions: o.Statement[]): o.Statement[] {
+  var condition: o.Expression = o.importExpr(resolveIdentifier(Identifiers.checkBinding)).callFn([
+    throwOnChangeVar, fieldExpr, evalResult.currValExpr
+  ]);
+  if (evalResult.forceUpdate) {
+    condition = evalResult.forceUpdate.or(condition);
+  }
+  return [
+    ...evalResult.stmts, new o.IfStmt(condition, actions.concat([
+      <o.Statement>o.THIS_EXPR.prop(fieldExpr.name).set(evalResult.currValExpr).toStmt()
+    ]))
+  ];
+}
+
+function createBindFieldExpr(bindingId: string): o.ReadPropExpr {
+  return o.THIS_EXPR.prop(`_expr_${bindingId}`);
+}

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

@@ -8,54 +8,132 @@
 
 
 import * as cdAst from '../expression_parser/ast';
-import {isArray, isBlank, isPresent} from '../facade/lang';
+import {isBlank, isPresent} from '../facade/lang';
 import {Identifiers, resolveIdentifier} from '../identifiers';
+import {ClassBuilder} from '../output/class_builder';
 import * as o from '../output/output_ast';
 
+import {createPureProxy} from './identifier_util';
+
+const VAL_UNWRAPPER_VAR = o.variable(`valUnwrapper`);
+
 export interface NameResolver {
   callPipe(name: string, input: o.Expression, args: o.Expression[]): o.Expression;
   getLocal(name: string): o.Expression;
-  createLiteralArray(values: o.Expression[]): o.Expression;
-  createLiteralMap(values: Array<Array<string|o.Expression>>): o.Expression;
 }
 
-export class ExpressionWithWrappedValueInfo {
+export class EventHandlerVars { static event = o.variable('$event'); }
+
+export class ConvertPropertyBindingResult {
   constructor(
-      public expression: o.Expression, public needsValueUnwrapper: boolean,
-      public temporaryCount: number) {}
+      public stmts: o.Statement[], public currValExpr: o.Expression,
+      public forceUpdate: o.Expression) {}
 }
 
-export function convertCdExpressionToIr(
-    nameResolver: NameResolver, implicitReceiver: o.Expression, expression: cdAst.AST,
-    valueUnwrapper: o.ReadVarExpr, bindingIndex: number): ExpressionWithWrappedValueInfo {
-  const visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, valueUnwrapper, bindingIndex);
-  const irAst: o.Expression = expression.visit(visitor, _Mode.Expression);
-  return new ExpressionWithWrappedValueInfo(
-      irAst, visitor.needsValueUnwrapper, visitor.temporaryCount);
+/**
+ * Converts the given expression AST into an executable output AST, assuming the expression is
+ * used in a property binding.
+ */
+export function convertPropertyBinding(
+    builder: ClassBuilder, nameResolver: NameResolver, implicitReceiver: o.Expression,
+    expression: cdAst.AST, bindingId: string): ConvertPropertyBindingResult {
+  const currValExpr = createCurrValueExpr(bindingId);
+  const stmts: o.Statement[] = [];
+  if (!nameResolver) {
+    nameResolver = new DefaultNameResolver();
+  }
+  const visitor = new _AstToIrVisitor(
+      builder, nameResolver, implicitReceiver, VAL_UNWRAPPER_VAR, bindingId, false);
+  const outputExpr: o.Expression = expression.visit(visitor, _Mode.Expression);
+
+  if (!outputExpr) {
+    // e.g. an empty expression was given
+    return null;
+  }
+
+  if (visitor.temporaryCount) {
+    for (let i = 0; i < visitor.temporaryCount; i++) {
+      stmts.push(temporaryDeclaration(bindingId, i));
+    }
+  }
+
+  if (visitor.needsValueUnwrapper) {
+    var initValueUnwrapperStmt = VAL_UNWRAPPER_VAR.callMethod('reset', []).toStmt();
+    stmts.push(initValueUnwrapperStmt);
+  }
+  stmts.push(currValExpr.set(outputExpr).toDeclStmt(null, [o.StmtModifier.Final]));
+  if (visitor.needsValueUnwrapper) {
+    return new ConvertPropertyBindingResult(
+        stmts, currValExpr, VAL_UNWRAPPER_VAR.prop('hasWrappedValue'));
+  } else {
+    return new ConvertPropertyBindingResult(stmts, currValExpr, null);
+  }
 }
 
-export function convertCdStatementToIr(
-    nameResolver: NameResolver, implicitReceiver: o.Expression, stmt: cdAst.AST,
-    bindingIndex: number): o.Statement[] {
-  const visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, null, bindingIndex);
-  let statements: o.Statement[] = [];
-  flattenStatements(stmt.visit(visitor, _Mode.Statement), statements);
-  prependTemporaryDecls(visitor.temporaryCount, bindingIndex, statements);
-  return statements;
+export class ConvertActionBindingResult {
+  constructor(public stmts: o.Statement[], public preventDefault: o.Expression) {}
 }
 
-function temporaryName(bindingIndex: number, temporaryNumber: number): string {
-  return `tmp_${bindingIndex}_${temporaryNumber}`;
+/**
+ * Converts the given expression AST into an executable output AST, assuming the expression is
+ * used in an action binding (e.g. an event handler).
+ */
+export function convertActionBinding(
+    builder: ClassBuilder, nameResolver: NameResolver, implicitReceiver: o.Expression,
+    action: cdAst.AST, bindingId: string): ConvertActionBindingResult {
+  if (!nameResolver) {
+    nameResolver = new DefaultNameResolver();
+  }
+  const visitor =
+      new _AstToIrVisitor(builder, nameResolver, implicitReceiver, null, bindingId, true);
+  let actionStmts: o.Statement[] = [];
+  flattenStatements(action.visit(visitor, _Mode.Statement), actionStmts);
+  prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
+  var lastIndex = actionStmts.length - 1;
+  var preventDefaultVar: o.ReadVarExpr = null;
+  if (lastIndex >= 0) {
+    var lastStatement = actionStmts[lastIndex];
+    var returnExpr = convertStmtIntoExpression(lastStatement);
+    if (returnExpr) {
+      // Note: We need to cast the result of the method call to dynamic,
+      // as it might be a void method!
+      preventDefaultVar = createPreventDefaultVar(bindingId);
+      actionStmts[lastIndex] =
+          preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
+              .toDeclStmt(null, [o.StmtModifier.Final]);
+    }
+  }
+  return new ConvertActionBindingResult(actionStmts, preventDefaultVar);
 }
 
-export function temporaryDeclaration(bindingIndex: number, temporaryNumber: number): o.Statement {
-  return new o.DeclareVarStmt(temporaryName(bindingIndex, temporaryNumber), o.NULL_EXPR);
+/**
+ * Creates variables that are shared by multiple calls to `convertActionBinding` /
+ * `convertPropertyBinding`
+ */
+export function createSharedBindingVariablesIfNeeded(stmts: o.Statement[]): o.Statement[] {
+  const unwrapperStmts: o.Statement[] = [];
+  var readVars = o.findReadVarNames(stmts);
+  if (readVars.has(VAL_UNWRAPPER_VAR.name)) {
+    unwrapperStmts.push(
+        VAL_UNWRAPPER_VAR
+            .set(o.importExpr(resolveIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
+            .toDeclStmt(null, [o.StmtModifier.Final]));
+  }
+  return unwrapperStmts;
+}
+
+function temporaryName(bindingId: string, temporaryNumber: number): string {
+  return `tmp_${bindingId}_${temporaryNumber}`;
+}
+
+export function temporaryDeclaration(bindingId: string, temporaryNumber: number): o.Statement {
+  return new o.DeclareVarStmt(temporaryName(bindingId, temporaryNumber), o.NULL_EXPR);
 }
 
 function prependTemporaryDecls(
-    temporaryCount: number, bindingIndex: number, statements: o.Statement[]) {
+    temporaryCount: number, bindingId: string, statements: o.Statement[]) {
   for (let i = temporaryCount - 1; i >= 0; i--) {
-    statements.unshift(temporaryDeclaration(bindingIndex, i));
+    statements.unshift(temporaryDeclaration(bindingId, i));
   }
 }
 
@@ -92,8 +170,9 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
   public temporaryCount: number = 0;
 
   constructor(
-      private _nameResolver: NameResolver, private _implicitReceiver: o.Expression,
-      private _valueUnwrapper: o.ReadVarExpr, private bindingIndex: number) {}
+      private _builder: ClassBuilder, private _nameResolver: NameResolver,
+      private _implicitReceiver: o.Expression, private _valueUnwrapper: o.ReadVarExpr,
+      private bindingId: string, private isAction: boolean) {}
 
   visitBinary(ast: cdAst.Binary, mode: _Mode): any {
     var op: o.BinaryOperator;
@@ -170,6 +249,9 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     const input = this.visit(ast.exp, _Mode.Expression);
     const args = this.visitAll(ast.args, _Mode.Expression);
     const value = this._nameResolver.callPipe(ast.name, input, args);
+    if (!value) {
+      throw new Error(`Illegal state: Pipe ${ast.name} is not allowed here!`);
+    }
     this.needsValueUnwrapper = true;
     return convertToStatementIfNeeded(mode, this._valueUnwrapper.callMethod('unwrap', [value]));
   }
@@ -209,8 +291,10 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
   }
 
   visitLiteralArray(ast: cdAst.LiteralArray, mode: _Mode): any {
-    return convertToStatementIfNeeded(
-        mode, this._nameResolver.createLiteralArray(this.visitAll(ast.expressions, mode)));
+    const parts = this.visitAll(ast.expressions, mode);
+    const literalArr =
+        this.isAction ? o.literalArr(parts) : createCachedLiteralArray(this._builder, parts);
+    return convertToStatementIfNeeded(mode, literalArr);
   }
 
   visitLiteralMap(ast: cdAst.LiteralMap, mode: _Mode): any {
@@ -218,13 +302,22 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     for (let i = 0; i < ast.keys.length; i++) {
       parts.push([ast.keys[i], this.visit(ast.values[i], _Mode.Expression)]);
     }
-    return convertToStatementIfNeeded(mode, this._nameResolver.createLiteralMap(parts));
+    const literalMap =
+        this.isAction ? o.literalMap(parts) : createCachedLiteralMap(this._builder, parts);
+    return convertToStatementIfNeeded(mode, literalMap);
   }
 
   visitLiteralPrimitive(ast: cdAst.LiteralPrimitive, mode: _Mode): any {
     return convertToStatementIfNeeded(mode, o.literal(ast.value));
   }
 
+  private _getLocal(name: string): o.Expression {
+    if (this.isAction && name == EventHandlerVars.event.name) {
+      return EventHandlerVars.event;
+    }
+    return this._nameResolver.getLocal(name);
+  }
+
   visitMethodCall(ast: cdAst.MethodCall, mode: _Mode): any {
     const leftMostSafe = this.leftMostSafeNode(ast);
     if (leftMostSafe) {
@@ -234,7 +327,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
       let result: any = null;
       let receiver = this.visit(ast.receiver, _Mode.Expression);
       if (receiver === this._implicitReceiver) {
-        var varExpr = this._nameResolver.getLocal(ast.name);
+        var varExpr = this._getLocal(ast.name);
         if (isPresent(varExpr)) {
           result = varExpr.callFn(args);
         }
@@ -258,7 +351,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
       let result: any = null;
       var receiver = this.visit(ast.receiver, _Mode.Expression);
       if (receiver === this._implicitReceiver) {
-        result = this._nameResolver.getLocal(ast.name);
+        result = this._getLocal(ast.name);
       }
       if (isBlank(result)) {
         result = receiver.prop(ast.name);
@@ -270,7 +363,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
   visitPropertyWrite(ast: cdAst.PropertyWrite, mode: _Mode): any {
     let receiver: o.Expression = this.visit(ast.receiver, _Mode.Expression);
     if (receiver === this._implicitReceiver) {
-      var varExpr = this._nameResolver.getLocal(ast.name);
+      var varExpr = this._getLocal(ast.name);
       if (isPresent(varExpr)) {
         throw new Error('Cannot assign to a reference or variable!');
       }
@@ -459,21 +552,87 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
   private allocateTemporary(): o.ReadVarExpr {
     const tempNumber = this._currentTemporary++;
     this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);
-    return new o.ReadVarExpr(temporaryName(this.bindingIndex, tempNumber));
+    return new o.ReadVarExpr(temporaryName(this.bindingId, tempNumber));
   }
 
   private releaseTemporary(temporary: o.ReadVarExpr) {
     this._currentTemporary--;
-    if (temporary.name != temporaryName(this.bindingIndex, this._currentTemporary)) {
+    if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {
       throw new Error(`Temporary ${temporary.name} released out of order`);
     }
   }
 }
 
 function flattenStatements(arg: any, output: o.Statement[]) {
-  if (isArray(arg)) {
+  if (Array.isArray(arg)) {
     (<any[]>arg).forEach((entry) => flattenStatements(entry, output));
   } else {
     output.push(arg);
   }
 }
+
+function createCachedLiteralArray(builder: ClassBuilder, values: o.Expression[]): o.Expression {
+  if (values.length === 0) {
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_ARRAY));
+  }
+  var proxyExpr = o.THIS_EXPR.prop(`_arr_${builder.fields.length}`);
+  var proxyParams: o.FnParam[] = [];
+  var proxyReturnEntries: o.Expression[] = [];
+  for (var i = 0; i < values.length; i++) {
+    var paramName = `p${i}`;
+    proxyParams.push(new o.FnParam(paramName));
+    proxyReturnEntries.push(o.variable(paramName));
+  }
+  createPureProxy(
+      o.fn(
+          proxyParams, [new o.ReturnStatement(o.literalArr(proxyReturnEntries))],
+          new o.ArrayType(o.DYNAMIC_TYPE)),
+      values.length, proxyExpr, builder);
+  return proxyExpr.callFn(values);
+}
+
+function createCachedLiteralMap(
+    builder: ClassBuilder, entries: [string, o.Expression][]): o.Expression {
+  if (entries.length === 0) {
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_MAP));
+  }
+  const proxyExpr = o.THIS_EXPR.prop(`_map_${builder.fields.length}`);
+  const proxyParams: o.FnParam[] = [];
+  const proxyReturnEntries: [string, o.Expression][] = [];
+  const values: o.Expression[] = [];
+  for (var i = 0; i < entries.length; i++) {
+    const paramName = `p${i}`;
+    proxyParams.push(new o.FnParam(paramName));
+    proxyReturnEntries.push([entries[i][0], o.variable(paramName)]);
+    values.push(<o.Expression>entries[i][1]);
+  }
+  createPureProxy(
+      o.fn(
+          proxyParams, [new o.ReturnStatement(o.literalMap(proxyReturnEntries))],
+          new o.MapType(o.DYNAMIC_TYPE)),
+      entries.length, proxyExpr, builder);
+  return proxyExpr.callFn(values);
+}
+
+
+class DefaultNameResolver implements NameResolver {
+  callPipe(name: string, input: o.Expression, args: o.Expression[]): o.Expression { return null; }
+  getLocal(name: string): o.Expression { return null; }
+}
+
+function createCurrValueExpr(bindingId: string): o.ReadVarExpr {
+  return o.variable(`currVal_${bindingId}`);  // fix syntax highlighting: `
+}
+
+function createPreventDefaultVar(bindingId: string): o.ReadVarExpr {
+  return o.variable(`pd_${bindingId}`);
+}
+
+function convertStmtIntoExpression(stmt: o.Statement): o.Expression {
+  if (stmt instanceof o.ExpressionStatement) {
+    return stmt.expr;
+  } else if (stmt instanceof o.ReturnStatement) {
+    return stmt.value;
+  }
+  return null;
+}

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

@@ -0,0 +1,60 @@
+/**
+ * @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} from '../compile_metadata';
+import {isPresent} from '../facade/lang';
+import {IdentifierSpec, Identifiers, resolveEnumIdentifier, resolveIdentifier} from '../identifiers';
+import * as o from '../output/output_ast';
+
+export function createDiTokenExpression(token: CompileTokenMetadata): o.Expression {
+  if (isPresent(token.value)) {
+    return o.literal(token.value);
+  } else if (token.identifierIsInstance) {
+    return o.importExpr(token.identifier)
+        .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
+  } else {
+    return o.importExpr(token.identifier);
+  }
+}
+
+export function createInlineArray(values: o.Expression[]): o.Expression {
+  if (values.length === 0) {
+    return o.importExpr(resolveIdentifier(Identifiers.EMPTY_INLINE_ARRAY));
+  }
+  const log2 = Math.log(values.length) / Math.log(2);
+  const index = Math.ceil(log2);
+  const identifierSpec = index < Identifiers.inlineArrays.length ? Identifiers.inlineArrays[index] :
+                                                                   Identifiers.InlineArrayDynamic;
+  const identifier = resolveIdentifier(identifierSpec);
+  return o.importExpr(identifier).instantiate([
+    <o.Expression>o.literal(values.length)
+  ].concat(values));
+}
+
+export function createPureProxy(
+    fn: o.Expression, argCount: number, pureProxyProp: o.ReadPropExpr,
+    builder: {fields: o.ClassField[], ctorStmts: {push: (stmt: o.Statement) => void}}) {
+  builder.fields.push(new o.ClassField(pureProxyProp.name, null));
+  var pureProxyId =
+      argCount < Identifiers.pureProxies.length ? Identifiers.pureProxies[argCount] : null;
+  if (!pureProxyId) {
+    throw new Error(`Unsupported number of argument for pure functions: ${argCount}`);
+  }
+  builder.ctorStmts.push(o.THIS_EXPR.prop(pureProxyProp.name)
+                             .set(o.importExpr(resolveIdentifier(pureProxyId)).callFn([fn]))
+                             .toStmt());
+}
+
+export function createEnumExpression(enumType: IdentifierSpec, enumValue: any): o.Expression {
+  const enumName =
+      Object.keys(enumType.runtime).find((propName) => enumType.runtime[propName] === enumValue);
+  if (!enumName) {
+    throw new Error(`Unknown enum value ${enumValue} in ${enumType.name}`);
+  }
+  return o.importExpr(resolveEnumIdentifier(resolveIdentifier(enumType), enumName));
+}

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

@@ -0,0 +1,89 @@
+/**
+ * @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 {SecurityContext} from '@angular/core';
+
+import {isPresent} from '../facade/lang';
+import {Identifiers, resolveIdentifier} from '../identifiers';
+import * as o from '../output/output_ast';
+import {BoundElementPropertyAst, PropertyBindingType} from '../template_parser/template_ast';
+
+import {createEnumExpression} from './identifier_util';
+
+export function writeToRenderer(
+    view: o.Expression, boundProp: BoundElementPropertyAst, renderElement: o.Expression,
+    renderValue: o.Expression, logBindingUpdate: boolean,
+    securityContextExpression?: o.Expression): o.Statement[] {
+  const updateStmts: o.Statement[] = [];
+  const renderer = view.prop('renderer');
+  renderValue = sanitizedValue(view, boundProp, renderValue, securityContextExpression);
+  switch (boundProp.type) {
+    case PropertyBindingType.Property:
+      if (logBindingUpdate) {
+        updateStmts.push(
+            o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfo))
+                .callFn([renderer, renderElement, o.literal(boundProp.name), renderValue])
+                .toStmt());
+      }
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementProperty', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
+      break;
+    case PropertyBindingType.Attribute:
+      renderValue =
+          renderValue.isBlank().conditional(o.NULL_EXPR, renderValue.callMethod('toString', []));
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementAttribute', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
+      break;
+    case PropertyBindingType.Class:
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementClass', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
+      break;
+    case PropertyBindingType.Style:
+      var strValue: o.Expression = renderValue.callMethod('toString', []);
+      if (isPresent(boundProp.unit)) {
+        strValue = strValue.plus(o.literal(boundProp.unit));
+      }
+
+      renderValue = renderValue.isBlank().conditional(o.NULL_EXPR, strValue);
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementStyle', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
+      break;
+    case PropertyBindingType.Animation:
+      throw new Error('Illegal state: Should not come here!');
+  }
+  return updateStmts;
+}
+
+function sanitizedValue(
+    view: o.Expression, boundProp: BoundElementPropertyAst, renderValue: o.Expression,
+    securityContextExpression?: o.Expression): o.Expression {
+  if (boundProp.securityContext === SecurityContext.NONE) {
+    return renderValue;  // No sanitization needed.
+  }
+  if (!boundProp.needsRuntimeSecurityContext) {
+    securityContextExpression =
+        createEnumExpression(Identifiers.SecurityContext, boundProp.securityContext);
+  }
+  if (!securityContextExpression) {
+    throw new Error(`internal error, no SecurityContext given ${boundProp.name}`);
+  }
+  let ctx = view.prop('viewUtils').prop('sanitizer');
+  let args = [securityContextExpression, renderValue];
+  return ctx.callMethod('sanitize', args);
+}

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

@@ -0,0 +1,277 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Injectable} from '@angular/core';
+
+import {CompileDirectiveMetadata, CompileIdentifierMetadata} from './compile_metadata';
+import {createCheckBindingField, createCheckBindingStmt} from './compiler_util/binding_util';
+import {convertPropertyBinding} from './compiler_util/expression_converter';
+import {writeToRenderer} from './compiler_util/render_util';
+import {CompilerConfig} from './config';
+import {Parser} from './expression_parser/parser';
+import {Identifiers, resolveIdentifier} from './identifiers';
+import {DEFAULT_INTERPOLATION_CONFIG} from './ml_parser/interpolation_config';
+import {ClassBuilder, createClassStmt} from './output/class_builder';
+import * as o from './output/output_ast';
+import {ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan} from './parse_util';
+import {Console, LifecycleHooks, isDefaultChangeDetectionStrategy} from './private_import_core';
+import {ElementSchemaRegistry} from './schema/element_schema_registry';
+import {BindingParser} from './template_parser/binding_parser';
+import {BoundElementPropertyAst, BoundEventAst} from './template_parser/template_ast';
+
+export class DirectiveWrapperCompileResult {
+  constructor(public statements: o.Statement[], public dirWrapperClassVar: string) {}
+}
+
+const CONTEXT_FIELD_NAME = 'context';
+const CHANGES_FIELD_NAME = 'changes';
+const CHANGED_FIELD_NAME = 'changed';
+
+const CURR_VALUE_VAR = o.variable('currValue');
+const THROW_ON_CHANGE_VAR = o.variable('throwOnChange');
+const FORCE_UPDATE_VAR = o.variable('forceUpdate');
+const VIEW_VAR = o.variable('view');
+const RENDER_EL_VAR = o.variable('el');
+
+const RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap([])).toStmt();
+
+/**
+ * We generate directive wrappers to prevent code bloat when a directive is used.
+ * A directive wrapper encapsulates
+ * the dirty checking for `@Input`, the handling of `@HostListener` / `@HostBinding`
+ * and calling the lifecyclehooks `ngOnInit`, `ngOnChanges`, `ngDoCheck`.
+ *
+ * So far, only `@Input` and the lifecycle hooks have been implemented.
+ */
+@Injectable()
+export class DirectiveWrapperCompiler {
+  static dirWrapperClassName(id: CompileIdentifierMetadata) { return `Wrapper_${id.name}`; }
+
+  constructor(
+      private compilerConfig: CompilerConfig, private _exprParser: Parser,
+      private _schemaRegistry: ElementSchemaRegistry, private _console: Console) {}
+
+  compile(dirMeta: CompileDirectiveMetadata): DirectiveWrapperCompileResult {
+    const builder = new DirectiveWrapperBuilder(this.compilerConfig, dirMeta);
+    Object.keys(dirMeta.inputs).forEach((inputFieldName) => {
+      addCheckInputMethod(inputFieldName, builder);
+    });
+    addDetectChangesInInputPropsMethod(builder);
+
+    const hostParseResult = parseHostBindings(dirMeta, this._exprParser, this._schemaRegistry);
+    reportParseErrors(hostParseResult.errors, this._console);
+    // host properties are change detected by the DirectiveWrappers,
+    // except for the animation properties as they need close integration with animation events
+    // and DirectiveWrappers don't support
+    // event listeners right now.
+    addDetectChangesInHostPropsMethod(
+        hostParseResult.hostProps.filter(hostProp => !hostProp.isAnimation), builder);
+
+    // TODO(tbosch): implement hostListeners via DirectiveWrapper as well!
+
+    const classStmt = builder.build();
+    return new DirectiveWrapperCompileResult([classStmt], classStmt.name);
+  }
+}
+
+class DirectiveWrapperBuilder implements ClassBuilder {
+  fields: o.ClassField[] = [];
+  getters: o.ClassGetter[] = [];
+  methods: o.ClassMethod[] = [];
+  ctorStmts: o.Statement[] = [];
+
+  genChanges: boolean;
+  ngOnChanges: boolean;
+  ngOnInit: boolean;
+  ngDoCheck: boolean;
+
+  constructor(public compilerConfig: CompilerConfig, public dirMeta: CompileDirectiveMetadata) {
+    const dirLifecycleHooks = dirMeta.type.lifecycleHooks;
+    this.genChanges = dirLifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1 ||
+        this.compilerConfig.logBindingUpdate;
+    this.ngOnChanges = dirLifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1;
+    this.ngOnInit = dirLifecycleHooks.indexOf(LifecycleHooks.OnInit) !== -1;
+    this.ngDoCheck = dirLifecycleHooks.indexOf(LifecycleHooks.DoCheck) !== -1;
+  }
+
+  build(): o.ClassStmt {
+    const dirDepParamNames: string[] = [];
+    for (let i = 0; i < this.dirMeta.type.diDeps.length; i++) {
+      dirDepParamNames.push(`p${i}`);
+    }
+
+    const fields: o.ClassField[] = [
+      new o.ClassField(CONTEXT_FIELD_NAME, o.importType(this.dirMeta.type)),
+      new o.ClassField(CHANGED_FIELD_NAME, o.BOOL_TYPE),
+    ];
+    const ctorStmts: o.Statement[] =
+        [o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt()];
+    if (this.genChanges) {
+      fields.push(new o.ClassField(CHANGES_FIELD_NAME, new o.MapType(o.DYNAMIC_TYPE)));
+      ctorStmts.push(RESET_CHANGES_STMT);
+    }
+
+    ctorStmts.push(
+        o.THIS_EXPR.prop(CONTEXT_FIELD_NAME)
+            .set(o.importExpr(this.dirMeta.type)
+                     .instantiate(dirDepParamNames.map((paramName) => o.variable(paramName))))
+            .toStmt());
+
+    return createClassStmt({
+      name: DirectiveWrapperCompiler.dirWrapperClassName(this.dirMeta.type),
+      ctorParams: dirDepParamNames.map((paramName) => new o.FnParam(paramName, o.DYNAMIC_TYPE)),
+      builders: [{fields, ctorStmts}, this]
+    });
+  }
+}
+
+function addDetectChangesInInputPropsMethod(builder: DirectiveWrapperBuilder) {
+  const changedVar = o.variable('changed');
+  const stmts: o.Statement[] = [
+    changedVar.set(o.THIS_EXPR.prop(CHANGED_FIELD_NAME)).toDeclStmt(),
+    o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt(),
+  ];
+  const lifecycleStmts: o.Statement[] = [];
+
+  if (builder.genChanges) {
+    const onChangesStmts: o.Statement[] = [];
+    if (builder.ngOnChanges) {
+      onChangesStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME)
+                              .callMethod('ngOnChanges', [o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])
+                              .toStmt());
+    }
+    if (builder.compilerConfig.logBindingUpdate) {
+      onChangesStmts.push(
+          o.importExpr(resolveIdentifier(Identifiers.setBindingDebugInfoForChanges))
+              .callFn(
+                  [VIEW_VAR.prop('renderer'), RENDER_EL_VAR, o.THIS_EXPR.prop(CHANGES_FIELD_NAME)])
+              .toStmt());
+    }
+    onChangesStmts.push(RESET_CHANGES_STMT);
+    lifecycleStmts.push(new o.IfStmt(changedVar, onChangesStmts));
+  }
+
+  if (builder.ngOnInit) {
+    lifecycleStmts.push(new o.IfStmt(
+        VIEW_VAR.prop('numberOfChecks').identical(new o.LiteralExpr(0)),
+        [o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngOnInit', []).toStmt()]));
+  }
+  if (builder.ngDoCheck) {
+    lifecycleStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngDoCheck', []).toStmt());
+  }
+  if (lifecycleStmts.length > 0) {
+    stmts.push(new o.IfStmt(o.not(THROW_ON_CHANGE_VAR), lifecycleStmts));
+  }
+  stmts.push(new o.ReturnStatement(changedVar));
+
+  builder.methods.push(new o.ClassMethod(
+      'detectChangesInInputProps',
+      [
+        new o.FnParam(
+            VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+        new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
+        new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
+      ],
+      stmts, o.BOOL_TYPE));
+}
+
+function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
+  const field = createCheckBindingField(builder);
+  var onChangeStatements: o.Statement[] = [
+    o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(true)).toStmt(),
+    o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).prop(input).set(CURR_VALUE_VAR).toStmt(),
+  ];
+  if (builder.genChanges) {
+    onChangeStatements.push(o.THIS_EXPR.prop(CHANGES_FIELD_NAME)
+                                .key(o.literal(input))
+                                .set(o.importExpr(resolveIdentifier(Identifiers.SimpleChange))
+                                         .instantiate([field.expression, CURR_VALUE_VAR]))
+                                .toStmt());
+  }
+
+  var methodBody: o.Statement[] = createCheckBindingStmt(
+      {currValExpr: CURR_VALUE_VAR, forceUpdate: FORCE_UPDATE_VAR, stmts: []}, field.expression,
+      THROW_ON_CHANGE_VAR, onChangeStatements);
+  builder.methods.push(new o.ClassMethod(
+      `check_${input}`,
+      [
+        new o.FnParam(CURR_VALUE_VAR.name, o.DYNAMIC_TYPE),
+        new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
+        new o.FnParam(FORCE_UPDATE_VAR.name, o.BOOL_TYPE),
+      ],
+      methodBody));
+}
+
+function addDetectChangesInHostPropsMethod(
+    hostProps: BoundElementPropertyAst[], builder: DirectiveWrapperBuilder) {
+  const stmts: o.Statement[] = [];
+  const methodParams: o.FnParam[] = [
+    new o.FnParam(
+        VIEW_VAR.name, o.importType(resolveIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
+    new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
+    new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
+  ];
+  hostProps.forEach((hostProp) => {
+    const field = createCheckBindingField(builder);
+    const evalResult = convertPropertyBinding(
+        builder, null, o.THIS_EXPR.prop(CONTEXT_FIELD_NAME), hostProp.value, field.bindingId);
+    if (!evalResult) {
+      return;
+    }
+    let securityContextExpr: o.ReadVarExpr;
+    if (hostProp.needsRuntimeSecurityContext) {
+      securityContextExpr = o.variable(`secCtx_${methodParams.length}`);
+      methodParams.push(new o.FnParam(
+          securityContextExpr.name, o.importType(resolveIdentifier(Identifiers.SecurityContext))));
+    }
+    stmts.push(...createCheckBindingStmt(
+        evalResult, field.expression, THROW_ON_CHANGE_VAR,
+        writeToRenderer(
+            VIEW_VAR, hostProp, RENDER_EL_VAR, evalResult.currValExpr,
+            builder.compilerConfig.logBindingUpdate, securityContextExpr)));
+  });
+  builder.methods.push(new o.ClassMethod('detectChangesInHostProps', methodParams, stmts));
+}
+
+class ParseResult {
+  constructor(
+      public hostProps: BoundElementPropertyAst[], public hostListeners: BoundEventAst[],
+      public errors: ParseError[]) {}
+}
+
+function parseHostBindings(
+    dirMeta: CompileDirectiveMetadata, exprParser: Parser,
+    schemaRegistry: ElementSchemaRegistry): ParseResult {
+  const errors: ParseError[] = [];
+  const parser =
+      new BindingParser(exprParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors);
+  const sourceFileName = dirMeta.type.moduleUrl ?
+      `in Directive ${dirMeta.type.name} in ${dirMeta.type.moduleUrl}` :
+      `in Directive ${dirMeta.type.name}`;
+  const sourceFile = new ParseSourceFile('', sourceFileName);
+  const sourceSpan = new ParseSourceSpan(
+      new ParseLocation(sourceFile, null, null, null),
+      new ParseLocation(sourceFile, null, null, null));
+  const parsedHostProps = parser.createDirectiveHostPropertyAsts(dirMeta, sourceSpan);
+  const parsedHostListeners = parser.createDirectiveHostEventAsts(dirMeta, sourceSpan);
+
+  return new ParseResult(parsedHostProps, parsedHostListeners, errors);
+}
+
+function reportParseErrors(parseErrors: ParseError[], console: Console) {
+  const warnings = parseErrors.filter(error => error.level === ParseErrorLevel.WARNING);
+  const errors = parseErrors.filter(error => error.level === ParseErrorLevel.FATAL);
+
+  if (warnings.length > 0) {
+    this._console.warn(`Directive parse warnings:\n${warnings.join('\n')}`);
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Directive parse errors:\n${errors.join('\n')}`);
+  }
+}

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

@@ -8,7 +8,7 @@
 
 import {Injectable} from '@angular/core';
 import * as chars from '../chars';
-import {NumberWrapper, StringJoiner, isPresent} from '../facade/lang';
+import {NumberWrapper, isPresent} from '../facade/lang';
 
 export enum TokenType {
   Character,
@@ -274,42 +274,41 @@ class _Scanner {
       }
       this.advance();
     }
-    var str: string = this.input.substring(start, this.index);
-    var value: number = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);
+    const str: string = this.input.substring(start, this.index);
+    const value: number = simple ? NumberWrapper.parseIntAutoRadix(str) : parseFloat(str);
     return newNumberToken(start, value);
   }
 
   scanString(): Token {
-    var start: number = this.index;
-    var quote: number = this.peek;
+    const start: number = this.index;
+    const quote: number = this.peek;
     this.advance();  // Skip initial quote.
 
-    var buffer: StringJoiner;
-    var marker: number = this.index;
-    var input: string = this.input;
+    let buffer: string = '';
+    let marker: number = this.index;
+    let input: string = this.input;
 
     while (this.peek != quote) {
       if (this.peek == chars.$BACKSLASH) {
-        if (buffer == null) buffer = new StringJoiner();
-        buffer.add(input.substring(marker, this.index));
+        buffer += input.substring(marker, this.index);
         this.advance();
-        var unescapedCode: number;
+        let unescapedCode: number;
         if (this.peek == chars.$u) {
           // 4 character hex code for unicode character.
-          var hex: string = input.substring(this.index + 1, this.index + 5);
+          const hex: string = input.substring(this.index + 1, this.index + 5);
           try {
             unescapedCode = NumberWrapper.parseInt(hex, 16);
           } catch (e) {
             return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
           }
-          for (var i: number = 0; i < 5; i++) {
+          for (let i: number = 0; i < 5; i++) {
             this.advance();
           }
         } else {
           unescapedCode = unescape(this.peek);
           this.advance();
         }
-        buffer.add(String.fromCharCode(unescapedCode));
+        buffer += String.fromCharCode(unescapedCode);
         marker = this.index;
       } else if (this.peek == chars.$EOF) {
         return this.error('Unterminated quote', 0);
@@ -318,16 +317,10 @@ class _Scanner {
       }
     }
 
-    var last: string = input.substring(marker, this.index);
+    const last: string = input.substring(marker, this.index);
     this.advance();  // Skip terminating quote.
 
-    // Compute the unescaped string value.
-    var unescaped: string = last;
-    if (buffer != null) {
-      buffer.add(last);
-      unescaped = buffer.toString();
-    }
-    return newStringToken(start, unescaped);
+    return newStringToken(start, buffer + last);
   }
 
   error(message: string, offset: number): Token {

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

@@ -60,10 +60,11 @@ export class Parser {
   parseSimpleBinding(
       input: string, location: string,
       interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {
-    var ast = this._parseBindingAst(input, location, interpolationConfig);
-    if (!SimpleExpressionChecker.check(ast)) {
+    const ast = this._parseBindingAst(input, location, interpolationConfig);
+    const errors = SimpleExpressionChecker.check(ast);
+    if (errors.length > 0) {
       this._reportError(
-          'Host binding expression can only contain field access and constants', input, location);
+          `Host binding expression cannot contain ${errors.join(' ')}`, input, location);
     }
     return new ASTWithSource(ast, input, location, this.errors);
   }
@@ -751,51 +752,51 @@ export class _ParseAST {
 }
 
 class SimpleExpressionChecker implements AstVisitor {
-  static check(ast: AST): boolean {
+  static check(ast: AST): string[] {
     var s = new SimpleExpressionChecker();
     ast.visit(s);
-    return s.simple;
+    return s.errors;
   }
 
-  simple = true;
+  errors: string[] = [];
 
   visitImplicitReceiver(ast: ImplicitReceiver, context: any) {}
 
-  visitInterpolation(ast: Interpolation, context: any) { this.simple = false; }
+  visitInterpolation(ast: Interpolation, context: any) {}
 
   visitLiteralPrimitive(ast: LiteralPrimitive, context: any) {}
 
   visitPropertyRead(ast: PropertyRead, context: any) {}
 
-  visitPropertyWrite(ast: PropertyWrite, context: any) { this.simple = false; }
+  visitPropertyWrite(ast: PropertyWrite, context: any) {}
 
-  visitSafePropertyRead(ast: SafePropertyRead, context: any) { this.simple = false; }
+  visitSafePropertyRead(ast: SafePropertyRead, context: any) {}
 
-  visitMethodCall(ast: MethodCall, context: any) { this.simple = false; }
+  visitMethodCall(ast: MethodCall, context: any) {}
 
-  visitSafeMethodCall(ast: SafeMethodCall, context: any) { this.simple = false; }
+  visitSafeMethodCall(ast: SafeMethodCall, context: any) {}
 
-  visitFunctionCall(ast: FunctionCall, context: any) { this.simple = false; }
+  visitFunctionCall(ast: FunctionCall, context: any) {}
 
   visitLiteralArray(ast: LiteralArray, context: any) { this.visitAll(ast.expressions); }
 
   visitLiteralMap(ast: LiteralMap, context: any) { this.visitAll(ast.values); }
 
-  visitBinary(ast: Binary, context: any) { this.simple = false; }
+  visitBinary(ast: Binary, context: any) {}
 
-  visitPrefixNot(ast: PrefixNot, context: any) { this.simple = false; }
+  visitPrefixNot(ast: PrefixNot, context: any) {}
 
-  visitConditional(ast: Conditional, context: any) { this.simple = false; }
+  visitConditional(ast: Conditional, context: any) {}
 
-  visitPipe(ast: BindingPipe, context: any) { this.simple = false; }
+  visitPipe(ast: BindingPipe, context: any) { this.errors.push('pipes'); }
 
-  visitKeyedRead(ast: KeyedRead, context: any) { this.simple = false; }
+  visitKeyedRead(ast: KeyedRead, context: any) {}
 
-  visitKeyedWrite(ast: KeyedWrite, context: any) { this.simple = false; }
+  visitKeyedWrite(ast: KeyedWrite, context: any) {}
 
   visitAll(asts: any[]): any[] { return asts.map(node => node.visit(this)); }
 
-  visitChain(ast: Chain, context: any) { this.simple = false; }
+  visitChain(ast: Chain, context: any) {}
 
-  visitQuote(ast: Quote, context: any) { this.simple = false; }
+  visitQuote(ast: Quote, context: any) {}
 }

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

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ANALYZE_FOR_ENTRY_COMPONENTS, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ElementRef, Injector, LOCALE_ID as LOCALE_ID_, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT as TRANSLATIONS_FORMAT_, TemplateRef, ViewContainerRef, ViewEncapsulation} from '@angular/core';
+import {ANALYZE_FOR_ENTRY_COMPONENTS, AnimationTransitionEvent, ChangeDetectionStrategy, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ElementRef, Injector, LOCALE_ID, NgModuleFactory, QueryList, RenderComponentType, Renderer, SecurityContext, SimpleChange, TRANSLATIONS_FORMAT, TemplateRef, ViewContainerRef, ViewEncapsulation} from '@angular/core';
 
 import {CompileIdentifierMetadata, CompileTokenMetadata} from './compile_metadata';
-import {AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppElement, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, DebugAppView, DebugContext, EMPTY_ARRAY, EMPTY_MAP, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, UNINITIALIZED, ValueUnwrapper, ViewType, ViewUtils, balanceAnimationKeyframes, castByValue, checkBinding, clearStyles, collectAndResolveStyles, devModeEqual, flattenNestedViewRenderNodes, interpolate, prepareFinalAnimationStyles, pureProxy1, pureProxy10, pureProxy2, pureProxy3, pureProxy4, pureProxy5, pureProxy6, pureProxy7, pureProxy8, pureProxy9, reflector, registerModuleFactory, renderStyles} from './private_import_core';
-import {assetUrl} from './util';
+import {AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppElement, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, DebugAppView, DebugContext, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, UNINITIALIZED, ValueUnwrapper, ViewType, balanceAnimationKeyframes, clearStyles, collectAndResolveStyles, devModeEqual, prepareFinalAnimationStyles, reflector, registerModuleFactory, renderStyles, view_utils} from './private_import_core';
 
 var APP_VIEW_MODULE_URL = assetUrl('core', 'linker/view');
 var VIEW_UTILS_MODULE_URL = assetUrl('core', 'linker/view_utils');
@@ -33,7 +32,7 @@ export class Identifiers {
   static ViewUtils: IdentifierSpec = {
     name: 'ViewUtils',
     moduleUrl: assetUrl('core', 'linker/view_utils'),
-    runtime: ViewUtils
+    runtime: view_utils.ViewUtils
   };
   static AppView:
       IdentifierSpec = {name: 'AppView', moduleUrl: APP_VIEW_MODULE_URL, runtime: AppView};
@@ -161,45 +160,57 @@ export class Identifiers {
   static checkBinding: IdentifierSpec = {
     name: 'checkBinding',
     moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: checkBinding
+    runtime: view_utils.checkBinding
   };
   static flattenNestedViewRenderNodes: IdentifierSpec = {
     name: 'flattenNestedViewRenderNodes',
     moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: flattenNestedViewRenderNodes
+    runtime: view_utils.flattenNestedViewRenderNodes
   };
   static devModeEqual:
       IdentifierSpec = {name: 'devModeEqual', moduleUrl: CD_MODULE_URL, runtime: devModeEqual};
   static interpolate: IdentifierSpec = {
     name: 'interpolate',
     moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: interpolate
+    runtime: view_utils.interpolate
   };
   static castByValue: IdentifierSpec = {
     name: 'castByValue',
     moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: castByValue
+    runtime: view_utils.castByValue
   };
   static EMPTY_ARRAY: IdentifierSpec = {
     name: 'EMPTY_ARRAY',
     moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: EMPTY_ARRAY
+    runtime: view_utils.EMPTY_ARRAY
   };
-  static EMPTY_MAP:
-      IdentifierSpec = {name: 'EMPTY_MAP', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: EMPTY_MAP};
-
-  static pureProxies = [
+  static EMPTY_MAP: IdentifierSpec = {
+    name: 'EMPTY_MAP',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.EMPTY_MAP
+  };
+  static createRenderElement: IdentifierSpec = {
+    name: 'createRenderElement',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.createRenderElement
+  };
+  static selectOrCreateRenderHostElement: IdentifierSpec = {
+    name: 'selectOrCreateRenderHostElement',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.selectOrCreateRenderHostElement
+  };
+  static pureProxies: IdentifierSpec[] = [
     null,
-    {name: 'pureProxy1', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy1},
-    {name: 'pureProxy2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy2},
-    {name: 'pureProxy3', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy3},
-    {name: 'pureProxy4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy4},
-    {name: 'pureProxy5', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy5},
-    {name: 'pureProxy6', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy6},
-    {name: 'pureProxy7', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy7},
-    {name: 'pureProxy8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy8},
-    {name: 'pureProxy9', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy9},
-    {name: 'pureProxy10', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: pureProxy10},
+    {name: 'pureProxy1', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy1},
+    {name: 'pureProxy2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy2},
+    {name: 'pureProxy3', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy3},
+    {name: 'pureProxy4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy4},
+    {name: 'pureProxy5', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy5},
+    {name: 'pureProxy6', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy6},
+    {name: 'pureProxy7', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy7},
+    {name: 'pureProxy8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy8},
+    {name: 'pureProxy9', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy9},
+    {name: 'pureProxy10', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.pureProxy10},
   ];
   static SecurityContext: IdentifierSpec = {
     name: 'SecurityContext',
@@ -259,18 +270,57 @@ export class Identifiers {
   static LOCALE_ID: IdentifierSpec = {
     name: 'LOCALE_ID',
     moduleUrl: assetUrl('core', 'i18n/tokens'),
-    runtime: LOCALE_ID_
+    runtime: LOCALE_ID
   };
   static TRANSLATIONS_FORMAT: IdentifierSpec = {
     name: 'TRANSLATIONS_FORMAT',
     moduleUrl: assetUrl('core', 'i18n/tokens'),
-    runtime: TRANSLATIONS_FORMAT_
+    runtime: TRANSLATIONS_FORMAT
+  };
+  static setBindingDebugInfo: IdentifierSpec = {
+    name: 'setBindingDebugInfo',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.setBindingDebugInfo
+  };
+  static setBindingDebugInfoForChanges: IdentifierSpec = {
+    name: 'setBindingDebugInfoForChanges',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.setBindingDebugInfoForChanges
   };
   static AnimationTransition: IdentifierSpec = {
     name: 'AnimationTransition',
     moduleUrl: assetUrl('core', 'animation/animation_transition'),
     runtime: AnimationTransition
   };
+
+  // This is just the interface!
+  static InlineArray:
+      IdentifierSpec = {name: 'InlineArray', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: null};
+  static inlineArrays: IdentifierSpec[] = [
+    {name: 'InlineArray2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray2},
+    {name: 'InlineArray2', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray2},
+    {name: 'InlineArray4', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray4},
+    {name: 'InlineArray8', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray8},
+    {name: 'InlineArray16', moduleUrl: VIEW_UTILS_MODULE_URL, runtime: view_utils.InlineArray16},
+  ];
+  static EMPTY_INLINE_ARRAY: IdentifierSpec = {
+    name: 'EMPTY_INLINE_ARRAY',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.EMPTY_INLINE_ARRAY
+  };
+  static InlineArrayDynamic: IdentifierSpec = {
+    name: 'InlineArrayDynamic',
+    moduleUrl: VIEW_UTILS_MODULE_URL,
+    runtime: view_utils.InlineArrayDynamic
+  };
+}
+
+export function assetUrl(pkg: string, path: string = null, type: string = 'src'): string {
+  if (path == null) {
+    return `asset:@angular/lib/${pkg}/index`;
+  } else {
+    return `asset:@angular/lib/${pkg}/src/${path}`;
+  }
 }
 
 export function resolveIdentifier(identifier: IdentifierSpec) {

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

@@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * @module
- * @description
- * Starting point to import all compiler APIs.
- */
-
-export {COMPILER_PROVIDERS, CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileFactoryMetadata, CompileIdentifierMetadata, CompileMetadataWithIdentifier, CompilePipeMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTemplateMetadata, CompileTokenMetadata, CompileTypeMetadata, CompilerConfig, DEFAULT_PACKAGE_URL_PROVIDER, DirectiveResolver, NgModuleResolver, OfflineCompiler, PipeResolver, RenderTypes, ResourceLoader, RuntimeCompiler, SourceModule, TEMPLATE_TRANSFORMS, UrlResolver, createOfflineCompileUrlResolver, platformCoreDynamic} from './compiler';
-export {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './ml_parser/interpolation_config';
-export {ElementSchemaRegistry} from './schema/element_schema_registry';
-export * from './i18n/index';
-export * from './template_parser/template_ast';
-export * from './private_export';

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

@@ -11,7 +11,7 @@ import {AnimationAnimateMetadata, AnimationEntryMetadata, AnimationGroupMetadata
 import {assertArrayOfStrings, assertInterpolationSymbols} from './assertions';
 import * as cpl from './compile_metadata';
 import {DirectiveResolver} from './directive_resolver';
-import {isBlank, isPresent, isString, stringify} from './facade/lang';
+import {isBlank, isPresent, stringify} from './facade/lang';
 import {Identifiers, resolveIdentifierToken} from './identifiers';
 import {hasLifecycleHook} from './lifecycle_reflector';
 import {NgModuleResolver} from './ng_module_resolver';
@@ -116,8 +116,7 @@ export class CompileMetadataResolver {
     return null;
   }
 
-  getDirectiveMetadata(directiveType: Type<any>, throwIfNotFound = true):
-      cpl.CompileDirectiveMetadata {
+  getDirectiveMetadata(directiveType: any, throwIfNotFound = true): cpl.CompileDirectiveMetadata {
     directiveType = resolveForwardRef(directiveType);
     let meta = this._directiveCache.get(directiveType);
     if (!meta) {
@@ -379,15 +378,15 @@ export class CompileMetadataResolver {
   }
 
   private _getTypeDescriptor(type: Type<any>): string {
-    if (this._directiveResolver.resolve(type, false) !== null) {
+    if (this._directiveResolver.resolve(type, false)) {
       return 'directive';
     }
 
-    if (this._pipeResolver.resolve(type, false) !== null) {
+    if (this._pipeResolver.resolve(type, false)) {
       return 'pipe';
     }
 
-    if (this._ngModuleResolver.resolve(type, false) !== null) {
+    if (this._ngModuleResolver.resolve(type, false)) {
       return 'module';
     }
 
@@ -509,7 +508,7 @@ export class CompileMetadataResolver {
       let isOptional = false;
       let query: Query = null;
       let viewQuery: Query = null;
-      var token: any = null;
+      let token: any = null;
       if (Array.isArray(param)) {
         param.forEach((paramEntry) => {
           if (paramEntry instanceof Host) {
@@ -569,7 +568,7 @@ export class CompileMetadataResolver {
   getTokenMetadata(token: any): cpl.CompileTokenMetadata {
     token = resolveForwardRef(token);
     let compileToken: cpl.CompileTokenMetadata;
-    if (isString(token)) {
+    if (typeof token === 'string') {
       compileToken = new cpl.CompileTokenMetadata({value: token});
     } else {
       compileToken = new cpl.CompileTokenMetadata({
@@ -606,19 +605,20 @@ export class CompileMetadataResolver {
       } else if (isValidType(provider)) {
         compileProvider = this.getTypeMetadata(provider, staticTypeModuleUrl(provider));
       } else {
-        let providersInfo = (<string[]>providers.reduce(
-                                 (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
-                                   if (seenProviderIdx < providerIdx) {
-                                     soFar.push(`${stringify(seenProvider)}`);
-                                   } else if (seenProviderIdx == providerIdx) {
-                                     soFar.push(`?${stringify(seenProvider)}?`);
-                                   } else if (seenProviderIdx == providerIdx + 1) {
-                                     soFar.push('...');
-                                   }
-                                   return soFar;
-                                 },
-                                 []))
-                                .join(', ');
+        const providersInfo =
+            (<string[]>providers.reduce(
+                 (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
+                   if (seenProviderIdx < providerIdx) {
+                     soFar.push(`${stringify(seenProvider)}`);
+                   } else if (seenProviderIdx == providerIdx) {
+                     soFar.push(`?${stringify(seenProvider)}?`);
+                   } else if (seenProviderIdx == providerIdx + 1) {
+                     soFar.push('...');
+                   }
+                   return soFar;
+                 },
+                 []))
+                .join(', ');
 
         throw new Error(
             `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`);

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

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ListWrapper} from '../facade/collection';
 import {isBlank, isPresent} from '../facade/lang';
 import {ParseError, ParseSourceSpan} from '../parse_util';
 
@@ -231,7 +230,7 @@ class _TreeBuilder {
 
   private _closeVoidElement(): void {
     if (this._elementStack.length > 0) {
-      const el = ListWrapper.last(this._elementStack);
+      const el = this._elementStack[this._elementStack.length - 1];
 
       if (this.getTagDefinition(el.name).isVoid) {
         this._elementStack.pop();
@@ -275,7 +274,7 @@ class _TreeBuilder {
 
   private _pushElement(el: html.Element) {
     if (this._elementStack.length > 0) {
-      const parentEl = ListWrapper.last(this._elementStack);
+      const parentEl = this._elementStack[this._elementStack.length - 1];
       if (this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {
         this._elementStack.pop();
       }
@@ -316,7 +315,7 @@ class _TreeBuilder {
     for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
       const el = this._elementStack[stackIndex];
       if (el.name == fullName) {
-        ListWrapper.splice(this._elementStack, stackIndex, this._elementStack.length - stackIndex);
+        this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
         return true;
       }
 
@@ -343,7 +342,7 @@ class _TreeBuilder {
   }
 
   private _getParentElement(): html.Element {
-    return this._elementStack.length > 0 ? ListWrapper.last(this._elementStack) : null;
+    return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
   }
 
   /**
@@ -361,7 +360,7 @@ class _TreeBuilder {
       container = this._elementStack[i];
     }
 
-    return {parent: ListWrapper.last(this._elementStack), container};
+    return {parent: this._elementStack[this._elementStack.length - 1], container};
   }
 
   private _addToParent(node: html.Node) {

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

@@ -9,15 +9,16 @@
 import {Injectable} from '@angular/core';
 
 import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata} from './compile_metadata';
+import {createDiTokenExpression} from './compiler_util/identifier_util';
 import {isPresent} from './facade/lang';
 import {Identifiers, resolveIdentifier, resolveIdentifierToken} from './identifiers';
+import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {convertValueToOutputAst} from './output/value_util';
 import {ParseLocation, ParseSourceFile, ParseSourceSpan} from './parse_util';
 import {LifecycleHooks} from './private_import_core';
 import {NgModuleProviderAnalyzer} from './provider_analyzer';
 import {ProviderAst} from './template_parser/template_ast';
-import {createDiTokenExpression} from './util';
 
 export class ComponentFactoryDependency {
   constructor(
@@ -82,13 +83,15 @@ export class NgModuleCompiler {
   }
 }
 
-class _InjectorBuilder {
+class _InjectorBuilder implements ClassBuilder {
+  fields: o.ClassField[] = [];
+  getters: o.ClassGetter[] = [];
+  methods: o.ClassMethod[] = [];
+  ctorStmts: o.Statement[] = [];
   private _tokens: CompileTokenMetadata[] = [];
   private _instances = new Map<any, o.Expression>();
-  private _fields: o.ClassField[] = [];
   private _createStmts: o.Statement[] = [];
   private _destroyStmts: o.Statement[] = [];
-  private _getters: o.ClassGetter[] = [];
 
   constructor(
       private _ngModuleMeta: CompileNgModuleMetadata,
@@ -136,26 +139,23 @@ class _InjectorBuilder {
       ),
     ];
 
-    var ctor = new o.ClassMethod(
-        null,
-        [new o.FnParam(
-            InjectorProps.parent.name, o.importType(resolveIdentifier(Identifiers.Injector)))],
-        [o.SUPER_EXPR
-             .callFn([
-               o.variable(InjectorProps.parent.name),
-               o.literalArr(this._entryComponentFactories.map(
-                   (componentFactory) => o.importExpr(componentFactory))),
-               o.literalArr(this._bootstrapComponentFactories.map(
-                   (componentFactory) => o.importExpr(componentFactory)))
-             ])
-             .toStmt()]);
-
+    var parentArgs = [
+      o.variable(InjectorProps.parent.name),
+      o.literalArr(
+          this._entryComponentFactories.map((componentFactory) => o.importExpr(componentFactory))),
+      o.literalArr(this._bootstrapComponentFactories.map(
+          (componentFactory) => o.importExpr(componentFactory)))
+    ];
     var injClassName = `${this._ngModuleMeta.type.name}Injector`;
-    return new o.ClassStmt(
-        injClassName, o.importExpr(
-                          resolveIdentifier(Identifiers.NgModuleInjector),
-                          [o.importType(this._ngModuleMeta.type)]),
-        this._fields, this._getters, ctor, methods);
+    return createClassStmt({
+      name: injClassName,
+      ctorParams: [new o.FnParam(
+          InjectorProps.parent.name, o.importType(resolveIdentifier(Identifiers.Injector)))],
+      parent: o.importExpr(
+          resolveIdentifier(Identifiers.NgModuleInjector), [o.importType(this._ngModuleMeta.type)]),
+      parentArgs: parentArgs,
+      builders: [{methods}, this]
+    });
   }
 
   private _getProviderValue(provider: CompileProviderMetadata): o.Expression {
@@ -194,11 +194,11 @@ class _InjectorBuilder {
       type = o.DYNAMIC_TYPE;
     }
     if (isEager) {
-      this._fields.push(new o.ClassField(propName, type));
+      this.fields.push(new o.ClassField(propName, type));
       this._createStmts.push(o.THIS_EXPR.prop(propName).set(resolvedProviderValueExpr).toStmt());
     } else {
       var internalField = `_${propName}`;
-      this._fields.push(new o.ClassField(internalField, type));
+      this.fields.push(new o.ClassField(internalField, type));
       // Note: Equals is important for JS so that it also checks the undefined case!
       var getterStmts = [
         new o.IfStmt(
@@ -206,7 +206,7 @@ class _InjectorBuilder {
             [o.THIS_EXPR.prop(internalField).set(resolvedProviderValueExpr).toStmt()]),
         new o.ReturnStatement(o.THIS_EXPR.prop(internalField))
       ];
-      this._getters.push(new o.ClassGetter(propName, getterStmts, type));
+      this.getters.push(new o.ClassGetter(propName, getterStmts, type));
     }
     return o.THIS_EXPR.prop(propName);
   }

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

@@ -12,6 +12,8 @@ import {AnimationCompiler} from './animation/animation_compiler';
 import {AnimationParser} from './animation/animation_parser';
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, StaticSymbol, createHostComponentMeta} from './compile_metadata';
 import {DirectiveNormalizer} from './directive_normalizer';
+import {DirectiveWrapperCompileResult, DirectiveWrapperCompiler} from './directive_wrapper_compiler';
+import {ListWrapper, MapWrapper} from './facade/collection';
 import {Identifiers, resolveIdentifier, resolveIdentifierToken} from './identifiers';
 import {CompileMetadataResolver} from './metadata_resolver';
 import {NgModuleCompiler} from './ng_module_compiler';
@@ -19,33 +21,91 @@ import {OutputEmitter} from './output/abstract_emitter';
 import * as o from './output/output_ast';
 import {CompiledStylesheet, StyleCompiler} from './style_compiler';
 import {TemplateParser} from './template_parser/template_parser';
-import {ComponentFactoryDependency, ViewCompileResult, ViewCompiler, ViewFactoryDependency} from './view_compiler/view_compiler';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewCompileResult, ViewCompiler, ViewFactoryDependency} from './view_compiler/view_compiler';
 
 export class SourceModule {
-  constructor(public moduleUrl: string, public source: string) {}
+  constructor(public fileUrl: string, public moduleUrl: string, public source: string) {}
 }
 
-export class NgModulesSummary {
-  constructor(
-      public ngModuleByComponent: Map<StaticSymbol, CompileNgModuleMetadata>,
-      public ngModules: CompileNgModuleMetadata[]) {}
-}
+// Returns all the source files and a mapping from modules to directives
+export function analyzeNgModules(
+    programStaticSymbols: StaticSymbol[], options: {transitiveModules: boolean},
+    metadataResolver: CompileMetadataResolver): {
+  ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
+  files: Array<{srcUrl: string, directives: StaticSymbol[], ngModules: StaticSymbol[]}>
+} {
+  const {
+    ngModules: programNgModules,
+    pipesAndDirectives: programPipesOrDirectives,
+  } = _extractModulesAndPipesOrDirectives(programStaticSymbols, metadataResolver);
 
-export function analyzeModules(
-    ngModules: StaticSymbol[], metadataResolver: CompileMetadataResolver) {
-  const ngModuleByComponent = new Map<StaticSymbol, CompileNgModuleMetadata>();
-  const modules: CompileNgModuleMetadata[] = [];
+  const moduleMetasByRef = new Map<any, CompileNgModuleMetadata>();
+
+  programNgModules.forEach(modMeta => {
+    if (options.transitiveModules) {
+      // For every input modules add the list of transitively included modules
+      modMeta.transitiveModule.modules.forEach(
+          modMeta => { moduleMetasByRef.set(modMeta.type.reference, modMeta); });
+    } else {
+      moduleMetasByRef.set(modMeta.type.reference, modMeta);
+    }
+  });
+
+  const ngModuleMetas = MapWrapper.values(moduleMetasByRef);
+  const ngModuleByPipeOrDirective = new Map<StaticSymbol, CompileNgModuleMetadata>();
+  const ngModulesByFile = new Map<string, StaticSymbol[]>();
+  const ngDirectivesByFile = new Map<string, StaticSymbol[]>();
+  const filePaths = new Set<string>();
+
+  // Looping over all modules to construct:
+  // - a map from file to modules `ngModulesByFile`,
+  // - a map from file to directives `ngDirectivesByFile`,
+  // - a map from directive/pipe to module `ngModuleByPipeOrDirective`.
+  ngModuleMetas.forEach((ngModuleMeta) => {
+    const srcFileUrl = ngModuleMeta.type.reference.filePath;
+    filePaths.add(srcFileUrl);
+    ngModulesByFile.set(
+        srcFileUrl, (ngModulesByFile.get(srcFileUrl) || []).concat(ngModuleMeta.type.reference));
 
-  ngModules.forEach((ngModule) => {
-    const ngModuleMeta = metadataResolver.getNgModuleMetadata(<any>ngModule);
-    modules.push(ngModuleMeta);
     ngModuleMeta.declaredDirectives.forEach((dirMeta: CompileDirectiveMetadata) => {
-      if (dirMeta.isComponent) {
-        ngModuleByComponent.set(dirMeta.type.reference, ngModuleMeta);
-      }
+      const fileUrl = dirMeta.type.reference.filePath;
+      filePaths.add(fileUrl);
+      ngDirectivesByFile.set(
+          fileUrl, (ngDirectivesByFile.get(fileUrl) || []).concat(dirMeta.type.reference));
+      ngModuleByPipeOrDirective.set(dirMeta.type.reference, ngModuleMeta);
+    });
+
+    ngModuleMeta.declaredPipes.forEach((pipeMeta: CompilePipeMetadata) => {
+      const fileUrl = pipeMeta.type.reference.filePath;
+      filePaths.add(fileUrl);
+      ngModuleByPipeOrDirective.set(pipeMeta.type.reference, ngModuleMeta);
     });
   });
-  return new NgModulesSummary(ngModuleByComponent, modules);
+
+  // Throw an error if any of the program pipe or directives is not declared by a module
+  const symbolsMissingModule =
+      programPipesOrDirectives.filter(s => !ngModuleByPipeOrDirective.has(s));
+
+  if (symbolsMissingModule.length) {
+    const messages = symbolsMissingModule.map(
+        s => `Cannot determine the module for class ${s.name} in ${s.filePath}!`);
+    throw new Error(messages.join('\n'));
+  }
+
+  const files: {srcUrl: string, directives: StaticSymbol[], ngModules: StaticSymbol[]}[] = [];
+
+  filePaths.forEach((srcUrl) => {
+    const directives = ngDirectivesByFile.get(srcUrl) || [];
+    const ngModules = ngModulesByFile.get(srcUrl) || [];
+    files.push({srcUrl, directives, ngModules});
+  });
+
+  return {
+      // map directive/pipe to module
+      ngModuleByPipeOrDirective,
+      // list modules and directives for every source file
+      files,
+  };
 }
 
 export class OfflineCompiler {
@@ -56,22 +116,32 @@ export class OfflineCompiler {
       private _metadataResolver: CompileMetadataResolver,
       private _directiveNormalizer: DirectiveNormalizer, private _templateParser: TemplateParser,
       private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
+      private _dirWrapperCompiler: DirectiveWrapperCompiler,
       private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
       private _localeId: string, private _translationFormat: string) {}
 
-  analyzeModules(ngModules: StaticSymbol[]): NgModulesSummary {
-    return analyzeModules(ngModules, this._metadataResolver);
-  }
-
   clearCache() {
     this._directiveNormalizer.clearCache();
     this._metadataResolver.clearCache();
   }
 
-  compile(
-      moduleUrl: string, ngModulesSummary: NgModulesSummary, components: StaticSymbol[],
-      ngModules: StaticSymbol[]): Promise<SourceModule[]> {
-    const fileSuffix = _splitTypescriptSuffix(moduleUrl)[1];
+  compileModules(staticSymbols: StaticSymbol[], options: {transitiveModules: boolean}):
+      Promise<SourceModule[]> {
+    const {ngModuleByPipeOrDirective, files} =
+        analyzeNgModules(staticSymbols, options, this._metadataResolver);
+
+    const sourceModules = files.map(
+        file => this._compileSrcFile(
+            file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.ngModules));
+
+    return Promise.all(sourceModules)
+        .then((modules: SourceModule[][]) => ListWrapper.flatten(modules));
+  }
+
+  private _compileSrcFile(
+      srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
+      directives: StaticSymbol[], ngModules: StaticSymbol[]): Promise<SourceModule[]> {
+    const fileSuffix = _splitTypescriptSuffix(srcFileUrl)[1];
     const statements: o.Statement[] = [];
     const exportedVars: string[] = [];
     const outputSourceModules: SourceModule[] = [];
@@ -80,13 +150,21 @@ export class OfflineCompiler {
     exportedVars.push(
         ...ngModules.map((ngModuleType) => this._compileModule(ngModuleType, statements)));
 
+    // compile directive wrappers
+    exportedVars.push(...directives.map(
+        (directiveType) => this._compileDirectiveWrapper(directiveType, statements)));
+
     // compile components
     return Promise
-        .all(components.map((compType) => {
-          const compMeta = this._metadataResolver.getDirectiveMetadata(<any>compType);
-          const ngModule = ngModulesSummary.ngModuleByComponent.get(compType);
+        .all(directives.map((dirType) => {
+          const compMeta = this._metadataResolver.getDirectiveMetadata(<any>dirType);
+          if (!compMeta.isComponent) {
+            return Promise.resolve(null);
+          }
+          const ngModule = ngModuleByPipeOrDirective.get(dirType);
           if (!ngModule) {
-            throw new Error(`Cannot determine the module for component ${compMeta.type.name}!`);
+            throw new Error(
+                `Internal Error: cannot determine the module for component ${compMeta.type.name}!`);
           }
 
           return Promise
@@ -99,7 +177,8 @@ export class OfflineCompiler {
                 // compile styles
                 const stylesCompileResults = this._styleCompiler.compileComponent(compMeta);
                 stylesCompileResults.externalStylesheets.forEach((compiledStyleSheet) => {
-                  outputSourceModules.push(this._codgenStyles(compiledStyleSheet, fileSuffix));
+                  outputSourceModules.push(
+                      this._codgenStyles(srcFileUrl, compiledStyleSheet, fileSuffix));
                 });
 
                 // compile components
@@ -112,8 +191,9 @@ export class OfflineCompiler {
         }))
         .then(() => {
           if (statements.length > 0) {
-            outputSourceModules.unshift(this._codegenSourceModule(
-                _ngfactoryModuleUrl(moduleUrl), statements, exportedVars));
+            const srcModule = this._codegenSourceModule(
+                srcFileUrl, _ngfactoryModuleUrl(srcFileUrl), statements, exportedVars);
+            outputSourceModules.unshift(srcModule);
           }
           return outputSourceModules;
         });
@@ -148,6 +228,15 @@ export class OfflineCompiler {
     return appCompileResult.ngModuleFactoryVar;
   }
 
+  private _compileDirectiveWrapper(directiveType: StaticSymbol, targetStatements: o.Statement[]):
+      string {
+    const dirMeta = this._metadataResolver.getDirectiveMetadata(directiveType);
+    const dirCompileResult = this._dirWrapperCompiler.compile(dirMeta);
+
+    targetStatements.push(...dirCompileResult.statements);
+    return dirCompileResult.dirWrapperClassVar;
+  }
+
   private _compileComponentFactory(
       compMeta: CompileDirectiveMetadata, fileSuffix: string,
       targetStatements: o.Statement[]): string {
@@ -193,18 +282,21 @@ export class OfflineCompiler {
     return viewResult.viewFactoryVar;
   }
 
-  private _codgenStyles(stylesCompileResult: CompiledStylesheet, fileSuffix: string): SourceModule {
+  private _codgenStyles(
+      fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): SourceModule {
     _resolveStyleStatements(stylesCompileResult, fileSuffix);
     return this._codegenSourceModule(
-        _stylesModuleUrl(
-            stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
+        fileUrl, _stylesModuleUrl(
+                     stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
         stylesCompileResult.statements, [stylesCompileResult.stylesVar]);
   }
 
   private _codegenSourceModule(
-      moduleUrl: string, statements: o.Statement[], exportedVars: string[]): SourceModule {
+      fileUrl: string, moduleUrl: string, statements: o.Statement[],
+      exportedVars: string[]): SourceModule {
     return new SourceModule(
-        moduleUrl, this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
+        fileUrl, moduleUrl,
+        this._outputEmitter.emitStatements(moduleUrl, statements, exportedVars));
   }
 }
 
@@ -217,6 +309,9 @@ function _resolveViewStatements(compileResult: ViewCompileResult): o.Statement[]
       const cfd = <ComponentFactoryDependency>dep;
       cfd.placeholder.name = _componentFactoryName(cfd.comp);
       cfd.placeholder.moduleUrl = _ngfactoryModuleUrl(cfd.comp.moduleUrl);
+    } else if (dep instanceof DirectiveWrapperDependency) {
+      const dwd = <DirectiveWrapperDependency>dep;
+      dwd.placeholder.moduleUrl = _ngfactoryModuleUrl(dwd.dir.moduleUrl);
     }
   });
   return compileResult.statements;
@@ -231,8 +326,8 @@ function _resolveStyleStatements(
   return compileResult.statements;
 }
 
-function _ngfactoryModuleUrl(compUrl: string): string {
-  const urlWithSuffix = _splitTypescriptSuffix(compUrl);
+function _ngfactoryModuleUrl(dirUrl: string): string {
+  const urlWithSuffix = _splitTypescriptSuffix(dirUrl);
   return `${urlWithSuffix[0]}.ngfactory${urlWithSuffix[1]}`;
 }
 
@@ -263,3 +358,28 @@ function _splitTypescriptSuffix(path: string): string[] {
 
   return [path, ''];
 }
+
+// Group the symbols by types:
+// - NgModules,
+// - Pipes and Directives.
+function _extractModulesAndPipesOrDirectives(
+    programStaticSymbols: StaticSymbol[], metadataResolver: CompileMetadataResolver) {
+  const ngModules: CompileNgModuleMetadata[] = [];
+  const pipesAndDirectives: StaticSymbol[] = [];
+
+  programStaticSymbols.forEach(staticSymbol => {
+    const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, false);
+    const directive = metadataResolver.getDirectiveMetadata(staticSymbol, false);
+    const pipe = metadataResolver.getPipeMetadata(<any>staticSymbol, false);
+
+    if (ngModule) {
+      ngModules.push(ngModule);
+    } else if (directive) {
+      pipesAndDirectives.push(staticSymbol);
+    } else if (pipe) {
+      pipesAndDirectives.push(staticSymbol);
+    }
+  });
+
+  return {ngModules, pipesAndDirectives};
+}

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

@@ -6,14 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {isBlank, isPresent, isString} from '../facade/lang';
+import {isBlank, isPresent} from '../facade/lang';
 
 import * as o from './output_ast';
 
-var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
-var _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;
-export var CATCH_ERROR_VAR = o.variable('error');
-export var CATCH_STACK_VAR = o.variable('stack');
+const _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
+const _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;
+export const CATCH_ERROR_VAR = o.variable('error');
+export const CATCH_STACK_VAR = o.variable('stack');
 
 export abstract class OutputEmitter {
   abstract emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string;
@@ -253,7 +253,7 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
   visitLiteralExpr(ast: o.LiteralExpr, ctx: EmitterVisitorContext, absentValue: string = 'null'):
       any {
     var value = ast.value;
-    if (isString(value)) {
+    if (typeof value === 'string') {
       ctx.print(escapeIdentifier(value, this._escapeDollarInStrings));
     } else if (isBlank(value)) {
       ctx.print(absentValue);

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

@@ -0,0 +1,60 @@
+/**
+ * @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 * as o from './output_ast';
+
+/**
+ * Create a new class stmts based on the given data.
+ */
+export function createClassStmt(config: {
+  name: string,
+  parent?: o.Expression,
+  parentArgs?: o.Expression[],
+  ctorParams?: o.FnParam[],
+  builders: ClassBuilderPart | ClassBuilderPart[], modifiers?: o.StmtModifier[]
+}): o.ClassStmt {
+  const parentArgs = config.parentArgs || [];
+  const superCtorStmts = config.parent ? [o.SUPER_EXPR.callFn(parentArgs).toStmt()] : [];
+  const builder =
+      concatClassBuilderParts(Array.isArray(config.builders) ? config.builders : [config.builders]);
+  const ctor =
+      new o.ClassMethod(null, config.ctorParams || [], superCtorStmts.concat(builder.ctorStmts));
+
+  return new o.ClassStmt(
+      config.name, config.parent, builder.fields, builder.getters, ctor, builder.methods,
+      config.modifiers || []);
+}
+
+function concatClassBuilderParts(builders: ClassBuilderPart[]) {
+  return {
+    fields: [].concat(...builders.map(builder => builder.fields || [])),
+    methods: [].concat(...builders.map(builder => builder.methods || [])),
+    getters: [].concat(...builders.map(builder => builder.getters || [])),
+    ctorStmts: [].concat(...builders.map(builder => builder.ctorStmts || [])),
+  };
+}
+
+/**
+ * Collects data for a generated class.
+ */
+export interface ClassBuilderPart {
+  fields?: o.ClassField[];
+  methods?: o.ClassMethod[];
+  getters?: o.ClassGetter[];
+  ctorStmts?: o.Statement[];
+}
+
+/**
+ * Collects data for a generated class.
+ */
+export interface ClassBuilder {
+  fields: o.ClassField[];
+  methods: o.ClassMethod[];
+  getters: o.ClassGetter[];
+  ctorStmts: o.Statement[];
+}

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

@@ -8,9 +8,7 @@
 
 
 import {CompileIdentifierMetadata} from '../compile_metadata';
-import {isPresent, isString} from '../facade/lang';
-
-
+import {isPresent} from '../facade/lang';
 
 //// Types
 export enum TypeModifier {
@@ -196,7 +194,7 @@ export class ReadVarExpr extends Expression {
 
   constructor(name: string|BuiltinVar, type: Type = null) {
     super(type);
-    if (isString(name)) {
+    if (typeof name === 'string') {
       this.name = name;
       this.builtin = null;
     } else {
@@ -267,7 +265,7 @@ export class InvokeMethodExpr extends Expression {
       public receiver: Expression, method: string|BuiltinMethod, public args: Expression[],
       type: Type = null) {
     super(type);
-    if (isString(method)) {
+    if (typeof method === 'string') {
       this.name = method;
       this.builtin = null;
     } else {

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

@@ -7,7 +7,6 @@
  */
 
 
-import {ListWrapper} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 
 import * as o from './output_ast';
@@ -81,7 +80,7 @@ function createDynamicClass(
     _executeFunctionStatements(
         ctorParamNames, args, _classStmt.constructorMethod.body, instanceCtx, _visitor);
   };
-  var superClass = _classStmt.parent.visitExpression(_visitor, _ctx);
+  var superClass = _classStmt.parent ? _classStmt.parent.visitExpression(_visitor, _ctx) : Object;
   ctor.prototype = Object.create(superClass.prototype, propertyDescriptors);
   return ctor;
 }
@@ -153,7 +152,7 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
     if (isPresent(expr.builtin)) {
       switch (expr.builtin) {
         case o.BuiltinMethod.ConcatArray:
-          result = ListWrapper.concat(receiver, args[0]);
+          result = receiver.concat(args[0]);
           break;
         case o.BuiltinMethod.SubscribeObservable:
           result = receiver.subscribe({next: args[0]});

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

@@ -6,13 +6,26 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {evalExpression, isPresent} from '../facade/lang';
+import {isPresent} from '../facade/lang';
 import {sanitizeIdentifier} from '../util';
 
 import {EmitterVisitorContext} from './abstract_emitter';
 import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
 import * as o from './output_ast';
 
+function evalExpression(
+    sourceUrl: string, expr: string, declarations: string, vars: {[key: string]: any}): any {
+  const fnBody = `${declarations}\nreturn ${expr}\n//# sourceURL=${sourceUrl}`;
+  const fnArgNames: string[] = [];
+  const fnArgValues: any[] = [];
+  for (const argName in vars) {
+    fnArgNames.push(argName);
+    fnArgValues.push(vars[argName]);
+  }
+  return new Function(...fnArgNames.concat(fnBody))(...fnArgValues);
+}
+
+
 export function jitStatements(
     sourceUrl: string, statements: o.Statement[], resultVar: string): any {
   var converter = new JitEmitterVisitor();

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

@@ -8,24 +8,20 @@
 
 
 import {CompileIdentifierMetadata} from '../compile_metadata';
-import {isArray, isBlank, isPresent} from '../facade/lang';
+import {isBlank, isPresent} from '../facade/lang';
 
 import {AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
 import * as o from './output_ast';
 import {ImportGenerator} from './path_util';
 
-var _debugModuleUrl = 'asset://debug/lib';
+const _debugModuleUrl = 'asset://debug/lib';
 
 export function debugOutputAstAsTypeScript(ast: o.Statement | o.Expression | o.Type | any[]):
     string {
-  var converter = new _TsEmitterVisitor(_debugModuleUrl);
-  var ctx = EmitterVisitorContext.createRoot([]);
-  var asts: any[];
-  if (isArray(ast)) {
-    asts = <any[]>ast;
-  } else {
-    asts = [ast];
-  }
+  const converter = new _TsEmitterVisitor(_debugModuleUrl);
+  const ctx = EmitterVisitorContext.createRoot([]);
+  const asts: any[] = Array.isArray(ast) ? ast : [ast];
+
   asts.forEach((ast) => {
     if (ast instanceof o.Statement) {
       ast.visitStatement(converter, ctx);

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

@@ -35,7 +35,7 @@ export enum ParseErrorLevel {
   FATAL
 }
 
-export abstract class ParseError {
+export class ParseError {
   constructor(
       public span: ParseSourceSpan, public msg: string,
       public level: ParseErrorLevel = ParseErrorLevel.FATAL) {}

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

@@ -1,112 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import * as directive_normalizer from './directive_normalizer';
-import * as lexer from './expression_parser/lexer';
-import * as parser from './expression_parser/parser';
-import * as metadata_resolver from './metadata_resolver';
-import * as html_parser from './ml_parser/html_parser';
-import * as interpolation_config from './ml_parser/interpolation_config';
-import * as ng_module_compiler from './ng_module_compiler';
-import * as path_util from './output/path_util';
-import * as ts_emitter from './output/ts_emitter';
-import * as parse_util from './parse_util';
-import * as dom_element_schema_registry from './schema/dom_element_schema_registry';
-import * as selector from './selector';
-import * as style_compiler from './style_compiler';
-import * as template_parser from './template_parser/template_parser';
-import * as view_compiler from './view_compiler/view_compiler';
-
-export const __compiler_private__: {
-  _SelectorMatcher?: selector.SelectorMatcher; SelectorMatcher: typeof selector.SelectorMatcher;
-
-  _CssSelector?: selector.CssSelector;
-  CssSelector: typeof selector.CssSelector;
-
-  _AssetUrl?: path_util.AssetUrl;
-  AssetUrl: typeof path_util.AssetUrl;
-
-  _ImportGenerator?: path_util.ImportGenerator;
-  ImportGenerator: typeof path_util.ImportGenerator;
-
-  _CompileMetadataResolver?: metadata_resolver.CompileMetadataResolver;
-  CompileMetadataResolver: typeof metadata_resolver.CompileMetadataResolver;
-
-  _HtmlParser?: html_parser.HtmlParser;
-  HtmlParser: typeof html_parser.HtmlParser;
-
-  _InterpolationConfig?: interpolation_config.InterpolationConfig;
-  InterpolationConfig: typeof interpolation_config.InterpolationConfig;
-
-  _DirectiveNormalizer?: directive_normalizer.DirectiveNormalizer;
-  DirectiveNormalizer: typeof directive_normalizer.DirectiveNormalizer;
-
-  _Lexer?: lexer.Lexer;
-  Lexer: typeof lexer.Lexer;
-
-  _Parser?: parser.Parser;
-  Parser: typeof parser.Parser;
-
-  _ParseLocation?: parse_util.ParseLocation;
-  ParseLocation: typeof parse_util.ParseLocation;
-
-  _ParseError?: parse_util.ParseError;
-  ParseError: typeof parse_util.ParseError;
-
-  _ParseErrorLevel?: parse_util.ParseErrorLevel;
-  ParseErrorLevel: typeof parse_util.ParseErrorLevel;
-
-  _ParseSourceFile?: parse_util.ParseSourceFile;
-  ParseSourceFile: typeof parse_util.ParseSourceFile;
-
-  _ParseSourceSpan?: parse_util.ParseSourceSpan;
-  ParseSourceSpan: typeof parse_util.ParseSourceSpan;
-
-  _TemplateParser?: template_parser.TemplateParser;
-  TemplateParser: typeof template_parser.TemplateParser;
-
-  _TemplateParseResult?: template_parser.TemplateParseResult;
-
-  _DomElementSchemaRegistry?: dom_element_schema_registry.DomElementSchemaRegistry;
-  DomElementSchemaRegistry: typeof dom_element_schema_registry.DomElementSchemaRegistry;
-
-  _StyleCompiler?: style_compiler.StyleCompiler;
-  StyleCompiler: typeof style_compiler.StyleCompiler;
-
-  _ViewCompiler?: view_compiler.ViewCompiler;
-  ViewCompiler: typeof view_compiler.ViewCompiler;
-
-  _NgModuleCompiler?: ng_module_compiler.NgModuleCompiler;
-  NgModuleCompiler: typeof ng_module_compiler.NgModuleCompiler;
-
-  _TypeScriptEmitter?: ts_emitter.TypeScriptEmitter;
-  TypeScriptEmitter: typeof ts_emitter.TypeScriptEmitter;
-
-} = {
-  SelectorMatcher: selector.SelectorMatcher,
-  CssSelector: selector.CssSelector,
-  AssetUrl: path_util.AssetUrl,
-  ImportGenerator: path_util.ImportGenerator,
-  CompileMetadataResolver: metadata_resolver.CompileMetadataResolver,
-  HtmlParser: html_parser.HtmlParser,
-  InterpolationConfig: interpolation_config.InterpolationConfig,
-  DirectiveNormalizer: directive_normalizer.DirectiveNormalizer,
-  Lexer: lexer.Lexer,
-  Parser: parser.Parser,
-  ParseLocation: parse_util.ParseLocation,
-  ParseError: parse_util.ParseError,
-  ParseErrorLevel: parse_util.ParseErrorLevel,
-  ParseSourceFile: parse_util.ParseSourceFile,
-  ParseSourceSpan: parse_util.ParseSourceSpan,
-  TemplateParser: template_parser.TemplateParser,
-  DomElementSchemaRegistry: dom_element_schema_registry.DomElementSchemaRegistry,
-  StyleCompiler: style_compiler.StyleCompiler,
-  ViewCompiler: view_compiler.ViewCompiler,
-  NgModuleCompiler: ng_module_compiler.NgModuleCompiler,
-  TypeScriptEmitter: ts_emitter.TypeScriptEmitter
-};

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

@@ -27,13 +27,7 @@ export const NgModuleInjector: typeof r.NgModuleInjector = r.NgModuleInjector;
 export const registerModuleFactory: typeof r.registerModuleFactory = r.registerModuleFactory;
 export type ViewType = typeof r._ViewType;
 export const ViewType: typeof r.ViewType = r.ViewType;
-export const MAX_INTERPOLATION_VALUES: typeof r.MAX_INTERPOLATION_VALUES =
-    r.MAX_INTERPOLATION_VALUES;
-export const checkBinding: typeof r.checkBinding = r.checkBinding;
-export const flattenNestedViewRenderNodes: typeof r.flattenNestedViewRenderNodes =
-    r.flattenNestedViewRenderNodes;
-export const interpolate: typeof r.interpolate = r.interpolate;
-export const ViewUtils: typeof r.ViewUtils = r.ViewUtils;
+export const view_utils: typeof r.view_utils = r.view_utils;
 export const DebugContext: typeof r.DebugContext = r.DebugContext;
 export const StaticNodeDebugInfo: typeof r.StaticNodeDebugInfo = r.StaticNodeDebugInfo;
 export const devModeEqual: typeof r.devModeEqual = r.devModeEqual;
@@ -42,19 +36,6 @@ export const ValueUnwrapper: typeof r.ValueUnwrapper = r.ValueUnwrapper;
 export const TemplateRef_: typeof r.TemplateRef_ = r.TemplateRef_;
 export type RenderDebugInfo = typeof r._RenderDebugInfo;
 export const RenderDebugInfo: typeof r.RenderDebugInfo = r.RenderDebugInfo;
-export const EMPTY_ARRAY: typeof r.EMPTY_ARRAY = r.EMPTY_ARRAY;
-export const EMPTY_MAP: typeof r.EMPTY_MAP = r.EMPTY_MAP;
-export const pureProxy1: typeof r.pureProxy1 = r.pureProxy1;
-export const pureProxy2: typeof r.pureProxy2 = r.pureProxy2;
-export const pureProxy3: typeof r.pureProxy3 = r.pureProxy3;
-export const pureProxy4: typeof r.pureProxy4 = r.pureProxy4;
-export const pureProxy5: typeof r.pureProxy5 = r.pureProxy5;
-export const pureProxy6: typeof r.pureProxy6 = r.pureProxy6;
-export const pureProxy7: typeof r.pureProxy7 = r.pureProxy7;
-export const pureProxy8: typeof r.pureProxy8 = r.pureProxy8;
-export const pureProxy9: typeof r.pureProxy9 = r.pureProxy9;
-export const pureProxy10: typeof r.pureProxy10 = r.pureProxy10;
-export const castByValue: typeof r.castByValue = r.castByValue;
 export type Console = typeof r._Console;
 export const Console: typeof r.Console = r.Console;
 export const reflector: typeof r.reflector = r.reflector;

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

@@ -8,8 +8,8 @@
 
 
 import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata} from './compile_metadata';
-import {ListWrapper, MapWrapper} from './facade/collection';
-import {isArray, isBlank, isPresent, normalizeBlank} from './facade/lang';
+import {MapWrapper} from './facade/collection';
+import {isBlank, isPresent} from './facade/lang';
 import {Identifiers, resolveIdentifierToken} from './identifiers';
 import {ParseError, ParseSourceSpan} from './parse_util';
 import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, ReferenceAst} from './template_parser/template_ast';
@@ -91,9 +91,9 @@ export class ProviderElementContext {
 
   get transformedDirectiveAsts(): DirectiveAst[] {
     var sortedProviderTypes = this.transformProviders.map(provider => provider.token.identifier);
-    var sortedDirectives = ListWrapper.clone(this._directiveAsts);
-    ListWrapper.sort(
-        sortedDirectives, (dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -
+    var sortedDirectives = this._directiveAsts.slice();
+    sortedDirectives.sort(
+        (dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -
             sortedProviderTypes.indexOf(dir2.directive.type));
     return sortedDirectives;
   }
@@ -117,7 +117,7 @@ export class ProviderElementContext {
     while (currentEl !== null) {
       queries = currentEl._contentQueries.get(token.reference);
       if (isPresent(queries)) {
-        ListWrapper.addAll(result, queries.filter((query) => query.descendants || distance <= 1));
+        result.push(...queries.filter((query) => query.descendants || distance <= 1));
       }
       if (currentEl._directiveAsts.length > 0) {
         distance++;
@@ -126,7 +126,7 @@ export class ProviderElementContext {
     }
     queries = this.viewContext.viewQueries.get(token.reference);
     if (isPresent(queries)) {
-      ListWrapper.addAll(result, queries);
+      result.push(...queries);
     }
     return result;
   }
@@ -194,7 +194,8 @@ export class ProviderElementContext {
       eager: boolean = null): CompileDiDependencyMetadata {
     if (dep.isAttribute) {
       var attrValue = this._attrs[dep.token.value];
-      return new CompileDiDependencyMetadata({isValue: true, value: normalizeBlank(attrValue)});
+      return new CompileDiDependencyMetadata(
+          {isValue: true, value: attrValue == null ? null : attrValue});
     }
     if (isPresent(dep.query) || isPresent(dep.viewQuery)) {
       return dep;
@@ -418,7 +419,7 @@ function _normalizeProviders(
   }
   if (isPresent(providers)) {
     providers.forEach((provider) => {
-      if (isArray(provider)) {
+      if (Array.isArray(provider)) {
         _normalizeProviders(<any[]>provider, sourceSpan, targetErrors, targetProviders);
       } else {
         let normalizeProvider: CompileProviderMetadata;
@@ -489,7 +490,7 @@ function _resolveProviders(
       targetProvidersByToken.set(provider.token.reference, resolvedProvider);
     } else {
       if (!provider.multi) {
-        ListWrapper.clear(resolvedProvider.providers);
+        resolvedProvider.providers.length = 0;
       }
       resolvedProvider.providers.push(provider);
     }

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

@@ -7,11 +7,13 @@
  */
 
 import {Compiler, ComponentFactory, Injectable, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
+
 import {AnimationCompiler} from './animation/animation_compiler';
 import {AnimationParser} from './animation/animation_parser';
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, ProviderMeta, createHostComponentMeta} from './compile_metadata';
 import {CompilerConfig} from './config';
 import {DirectiveNormalizer} from './directive_normalizer';
+import {DirectiveWrapperCompiler} from './directive_wrapper_compiler';
 import {stringify} from './facade/lang';
 import {CompileMetadataResolver} from './metadata_resolver';
 import {NgModuleCompiler} from './ng_module_compiler';
@@ -22,7 +24,8 @@ import {ComponentStillLoadingError} from './private_import_core';
 import {CompiledStylesheet, StyleCompiler} from './style_compiler';
 import {TemplateParser} from './template_parser/template_parser';
 import {SyncAsyncResult} from './util';
-import {ComponentFactoryDependency, ViewCompiler, ViewFactoryDependency} from './view_compiler/view_compiler';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewCompiler, ViewFactoryDependency} from './view_compiler/view_compiler';
+
 
 /**
  * An internal module of the Angular compiler that begins with component types,
@@ -37,6 +40,7 @@ import {ComponentFactoryDependency, ViewCompiler, ViewFactoryDependency} from '.
 export class RuntimeCompiler implements Compiler {
   private _compiledTemplateCache = new Map<Type<any>, CompiledTemplate>();
   private _compiledHostTemplateCache = new Map<Type<any>, CompiledTemplate>();
+  private _compiledDirectiveWrapperCache = new Map<Type<any>, Type<any>>();
   private _compiledNgModuleCache = new Map<Type<any>, NgModuleFactory<any>>();
   private _animationParser = new AnimationParser();
   private _animationCompiler = new AnimationCompiler();
@@ -45,7 +49,9 @@ export class RuntimeCompiler implements Compiler {
       private _injector: Injector, private _metadataResolver: CompileMetadataResolver,
       private _templateNormalizer: DirectiveNormalizer, private _templateParser: TemplateParser,
       private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
-      private _ngModuleCompiler: NgModuleCompiler, private _compilerConfig: CompilerConfig) {}
+      private _ngModuleCompiler: NgModuleCompiler,
+      private _directiveWrapperCompiler: DirectiveWrapperCompiler,
+      private _compilerConfig: CompilerConfig) {}
 
   get injector(): Injector { return this._injector; }
 
@@ -80,10 +86,11 @@ export class RuntimeCompiler implements Compiler {
     const moduleMeta = this._metadataResolver.getNgModuleMetadata(moduleType);
     const componentFactories: ComponentFactory<any>[] = [];
     const templates = new Set<CompiledTemplate>();
-    moduleMeta.transitiveModule.modules.forEach((moduleMeta) => {
-      moduleMeta.declaredDirectives.forEach((dirMeta) => {
+    moduleMeta.transitiveModule.modules.forEach((localModuleMeta) => {
+      localModuleMeta.declaredDirectives.forEach((dirMeta) => {
         if (dirMeta.isComponent) {
-          const template = this._createCompiledHostTemplate(dirMeta.type.reference);
+          const template =
+              this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);
           templates.add(template);
           componentFactories.push(template.proxyComponentFactory);
         }
@@ -119,7 +126,7 @@ export class RuntimeCompiler implements Compiler {
             interpretStatements(compileResult.statements, compileResult.ngModuleFactoryVar);
       } else {
         ngModuleFactory = jitStatements(
-            `${moduleMeta.type.name}.ngfactory.js`, compileResult.statements,
+            `/${moduleMeta.type.name}/module.ngfactory.js`, compileResult.statements,
             compileResult.ngModuleFactoryVar);
       }
       this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory);
@@ -135,22 +142,32 @@ export class RuntimeCompiler implements Compiler {
     var loadingPromises: Promise<any>[] = [];
 
     const ngModule = this._metadataResolver.getNgModuleMetadata(mainModule);
+    const moduleByDirective = new Map<any, CompileNgModuleMetadata>();
+    ngModule.transitiveModule.modules.forEach((localModuleMeta) => {
+      localModuleMeta.declaredDirectives.forEach((dirMeta) => {
+        moduleByDirective.set(dirMeta.type.reference, localModuleMeta);
+        this._compileDirectiveWrapper(dirMeta, localModuleMeta);
+        if (dirMeta.isComponent) {
+          templates.add(this._createCompiledTemplate(dirMeta, localModuleMeta));
+        }
+      });
+    });
     ngModule.transitiveModule.modules.forEach((localModuleMeta) => {
       localModuleMeta.declaredDirectives.forEach((dirMeta) => {
         if (dirMeta.isComponent) {
-          templates.add(this._createCompiledTemplate(dirMeta, localModuleMeta));
           dirMeta.entryComponents.forEach((entryComponentType) => {
-            templates.add(this._createCompiledHostTemplate(entryComponentType.reference));
+            const moduleMeta = moduleByDirective.get(entryComponentType.reference);
+            templates.add(
+                this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));
           });
-          // TODO: what about entryComponents of entryComponents? maybe skip here and just do the
-          // below?
         }
       });
       localModuleMeta.entryComponents.forEach((entryComponentType) => {
-        templates.add(this._createCompiledHostTemplate(entryComponentType.reference));
-        // TODO: what about entryComponents of entryComponents?
+        const moduleMeta = moduleByDirective.get(entryComponentType.reference);
+        templates.add(this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));
       });
     });
+
     templates.forEach((template) => {
       if (template.loading) {
         if (isSync) {
@@ -189,14 +206,19 @@ export class RuntimeCompiler implements Compiler {
     this._compiledNgModuleCache.clear();
   }
 
-  private _createCompiledHostTemplate(compType: Type<any>): CompiledTemplate {
+  private _createCompiledHostTemplate(compType: Type<any>, ngModule: CompileNgModuleMetadata):
+      CompiledTemplate {
+    if (!ngModule) {
+      throw new Error(
+          `Component ${stringify(compType)} is not part of any NgModule or the module has not been imported into your module.`);
+    }
     var compiledTemplate = this._compiledHostTemplateCache.get(compType);
     if (!compiledTemplate) {
       var compMeta = this._metadataResolver.getDirectiveMetadata(compType);
       assertComponent(compMeta);
       var hostMeta = createHostComponentMeta(compMeta);
       compiledTemplate = new CompiledTemplate(
-          true, compMeta.selector, compMeta.type, [compMeta], [], [],
+          true, compMeta.selector, compMeta.type, ngModule, [compMeta],
           this._templateNormalizer.normalizeDirective(hostMeta));
       this._compiledHostTemplateCache.set(compType, compiledTemplate);
     }
@@ -209,8 +231,7 @@ export class RuntimeCompiler implements Compiler {
     if (!compiledTemplate) {
       assertComponent(compMeta);
       compiledTemplate = new CompiledTemplate(
-          false, compMeta.selector, compMeta.type, ngModule.transitiveModule.directives,
-          ngModule.transitiveModule.pipes, ngModule.schemas,
+          false, compMeta.selector, compMeta.type, ngModule, ngModule.transitiveModule.directives,
           this._templateNormalizer.normalizeDirective(compMeta));
       this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);
     }
@@ -221,13 +242,8 @@ export class RuntimeCompiler implements Compiler {
     const compiledTemplate = isHost ? this._compiledHostTemplateCache.get(compType) :
                                       this._compiledTemplateCache.get(compType);
     if (!compiledTemplate) {
-      if (isHost) {
-        throw new Error(
-            `Illegal state: Compiled view for component ${stringify(compType)} does not exist!`);
-      } else {
-        throw new Error(
-            `Component ${stringify(compType)} is not part of any NgModule or the module has not been imported into your module.`);
-      }
+      throw new Error(
+          `Illegal state: Compiled view for component ${stringify(compType)} does not exist!`);
     }
     return compiledTemplate;
   }
@@ -241,6 +257,30 @@ export class RuntimeCompiler implements Compiler {
     return compiledTemplate;
   }
 
+  private _assertDirectiveWrapper(dirType: any): Type<any> {
+    const dirWrapper = this._compiledDirectiveWrapperCache.get(dirType);
+    if (!dirWrapper) {
+      throw new Error(
+          `Illegal state: Directive wrapper for ${stringify(dirType)} has not been compiled!`);
+    }
+    return dirWrapper;
+  }
+
+  private _compileDirectiveWrapper(
+      dirMeta: CompileDirectiveMetadata, moduleMeta: CompileNgModuleMetadata): void {
+    const compileResult = this._directiveWrapperCompiler.compile(dirMeta);
+    const statements = compileResult.statements;
+    let directiveWrapperClass: any;
+    if (!this._compilerConfig.useJit) {
+      directiveWrapperClass = interpretStatements(statements, compileResult.dirWrapperClassVar);
+    } else {
+      directiveWrapperClass = jitStatements(
+          `/${moduleMeta.type.name}/${dirMeta.type.name}/wrapper.ngfactory.js`, statements,
+          compileResult.dirWrapperClassVar);
+    }
+    this._compiledDirectiveWrapperCache.set(dirMeta.type.reference, directiveWrapperClass);
+  }
+
   private _compileTemplate(template: CompiledTemplate) {
     if (template.isCompiled) {
       return;
@@ -275,6 +315,9 @@ export class RuntimeCompiler implements Compiler {
         depTemplate = this._assertComponentLoaded(cfd.comp.reference, true);
         cfd.placeholder.reference = depTemplate.proxyComponentFactory;
         cfd.placeholder.name = `compFactory_${cfd.comp.name}`;
+      } else if (dep instanceof DirectiveWrapperDependency) {
+        let dwd = <DirectiveWrapperDependency>dep;
+        dwd.placeholder.reference = this._assertDirectiveWrapper(dwd.dir.reference);
       }
     });
     const statements =
@@ -286,8 +329,8 @@ export class RuntimeCompiler implements Compiler {
       factory = interpretStatements(statements, compileResult.viewFactoryVar);
     } else {
       factory = jitStatements(
-          `${template.compType.name}${template.isHost?'_Host':''}.ngfactory.js`, statements,
-          compileResult.viewFactoryVar);
+          `/${template.ngModule.type.name}/${template.compType.name}/${template.isHost?'host':'component'}.ngfactory.js`,
+          statements, compileResult.viewFactoryVar);
     }
     template.compiled(factory);
   }
@@ -310,7 +353,7 @@ export class RuntimeCompiler implements Compiler {
     if (!this._compilerConfig.useJit) {
       return interpretStatements(result.statements, result.stylesVar);
     } else {
-      return jitStatements(`${result.meta.moduleUrl}.css.js`, result.statements, result.stylesVar);
+      return jitStatements(`/${result.meta.moduleUrl}.css.js`, result.statements, result.stylesVar);
     }
   }
 }
@@ -325,13 +368,17 @@ class CompiledTemplate {
   isCompiledWithDeps = false;
   viewComponentTypes: Type<any>[] = [];
   viewDirectives: CompileDirectiveMetadata[] = [];
+  viewPipes: CompilePipeMetadata[];
+  schemas: SchemaMetadata[];
 
   constructor(
       public isHost: boolean, selector: string, public compType: CompileIdentifierMetadata,
-      viewDirectivesAndComponents: CompileDirectiveMetadata[],
-      public viewPipes: CompilePipeMetadata[], public schemas: SchemaMetadata[],
+      public ngModule: CompileNgModuleMetadata,
+      viewDirectiveAndComponents: CompileDirectiveMetadata[],
       _normalizeResult: SyncAsyncResult<CompileDirectiveMetadata>) {
-    viewDirectivesAndComponents.forEach((dirMeta) => {
+    this.viewPipes = ngModule.transitiveModule.pipes;
+    this.schemas = ngModule.schemas;
+    viewDirectiveAndComponents.forEach((dirMeta) => {
       if (dirMeta.isComponent) {
         this.viewComponentTypes.push(dirMeta.type.reference);
       } else {

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

@@ -328,7 +328,12 @@ export class DomElementSchemaRegistry extends ElementSchemaRegistry {
    * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known
    * attack vectors are assigned their appropriate context.
    */
-  securityContext(tagName: string, propName: string): SecurityContext {
+  securityContext(tagName: string, propName: string, isAttribute: boolean): SecurityContext {
+    if (isAttribute) {
+      // NB: For security purposes, use the mapped property name, not the attribute name.
+      propName = this.getMappedPropName(propName);
+    }
+
     // Make sure comparisons are case insensitive, so that case differences between attribute and
     // property names do not have a security impact.
     tagName = tagName.toLowerCase();
@@ -366,4 +371,6 @@ export class DomElementSchemaRegistry extends ElementSchemaRegistry {
       return {error: false};
     }
   }
+
+  allKnownElementNames(): string[] { return Object.keys(this._schema); }
 }

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

@@ -6,12 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {SchemaMetadata} from '@angular/core';
+import {SchemaMetadata, SecurityContext} from '@angular/core';
 
 export abstract class ElementSchemaRegistry {
   abstract hasProperty(tagName: string, propName: string, schemaMetas: SchemaMetadata[]): boolean;
   abstract hasElement(tagName: string, schemaMetas: SchemaMetadata[]): boolean;
-  abstract securityContext(tagName: string, propName: string): any;
+  abstract securityContext(elementName: string, propName: string, isAttribute: boolean):
+      SecurityContext;
+  abstract allKnownElementNames(): string[];
   abstract getMappedPropName(propName: string): string;
   abstract getDefaultComponentElementName(): string;
   abstract validateProperty(name: string): {error: boolean, msg?: string};

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

@@ -135,12 +135,12 @@ export class SelectorMatcher {
     return notMatcher;
   }
 
-  private _elementMap: {[k: string]: SelectorContext[]} = {};
-  private _elementPartialMap: {[k: string]: SelectorMatcher} = {};
-  private _classMap: {[k: string]: SelectorContext[]} = {};
-  private _classPartialMap: {[k: string]: SelectorMatcher} = {};
-  private _attrValueMap: {[k: string]: {[k: string]: SelectorContext[]}} = {};
-  private _attrValuePartialMap: {[k: string]: {[k: string]: SelectorMatcher}} = {};
+  private _elementMap = new Map<string, SelectorContext[]>();
+  private _elementPartialMap = new Map<string, SelectorMatcher>();
+  private _classMap = new Map<string, SelectorContext[]>();
+  private _classPartialMap = new Map<string, SelectorMatcher>();
+  private _attrValueMap = new Map<string, Map<string, SelectorContext[]>>();
+  private _attrValuePartialMap = new Map<string, Map<string, SelectorMatcher>>();
   private _listContexts: SelectorListContext[] = [];
 
   addSelectables(cssSelectors: CssSelector[], callbackCtxt?: any) {
@@ -195,18 +195,18 @@ export class SelectorMatcher {
         const value = attrs[i + 1];
         if (isTerminal) {
           const terminalMap = matcher._attrValueMap;
-          let terminalValuesMap = terminalMap[name];
+          let terminalValuesMap = terminalMap.get(name);
           if (!terminalValuesMap) {
-            terminalValuesMap = {};
-            terminalMap[name] = terminalValuesMap;
+            terminalValuesMap = new Map<string, SelectorContext[]>();
+            terminalMap.set(name, terminalValuesMap);
           }
           this._addTerminal(terminalValuesMap, value, selectable);
         } else {
           let partialMap = matcher._attrValuePartialMap;
-          let partialValuesMap = partialMap[name];
+          let partialValuesMap = partialMap.get(name);
           if (!partialValuesMap) {
-            partialValuesMap = {};
-            partialMap[name] = partialValuesMap;
+            partialValuesMap = new Map<string, SelectorMatcher>();
+            partialMap.set(name, partialValuesMap);
           }
           matcher = this._addPartial(partialValuesMap, value);
         }
@@ -215,20 +215,20 @@ export class SelectorMatcher {
   }
 
   private _addTerminal(
-      map: {[k: string]: SelectorContext[]}, name: string, selectable: SelectorContext) {
-    let terminalList = map[name];
+      map: Map<string, SelectorContext[]>, name: string, selectable: SelectorContext) {
+    let terminalList = map.get(name);
     if (!terminalList) {
       terminalList = [];
-      map[name] = terminalList;
+      map.set(name, terminalList);
     }
     terminalList.push(selectable);
   }
 
-  private _addPartial(map: {[k: string]: SelectorMatcher}, name: string): SelectorMatcher {
-    let matcher = map[name];
+  private _addPartial(map: Map<string, SelectorMatcher>, name: string): SelectorMatcher {
+    let matcher = map.get(name);
     if (!matcher) {
       matcher = new SelectorMatcher();
-      map[name] = matcher;
+      map.set(name, matcher);
     }
     return matcher;
   }
@@ -270,7 +270,7 @@ export class SelectorMatcher {
         const name = attrs[i];
         const value = attrs[i + 1];
 
-        const terminalValuesMap = this._attrValueMap[name];
+        const terminalValuesMap = this._attrValueMap.get(name);
         if (value) {
           result =
               this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result;
@@ -278,7 +278,7 @@ export class SelectorMatcher {
         result =
             this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;
 
-        const partialValuesMap = this._attrValuePartialMap[name];
+        const partialValuesMap = this._attrValuePartialMap.get(name);
         if (value) {
           result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result;
         }
@@ -291,14 +291,14 @@ export class SelectorMatcher {
 
   /** @internal */
   _matchTerminal(
-      map: {[k: string]: SelectorContext[]}, name: string, cssSelector: CssSelector,
+      map: Map<string, SelectorContext[]>, name: string, cssSelector: CssSelector,
       matchedCallback: (c: CssSelector, a: any) => void): boolean {
     if (!map || typeof name !== 'string') {
       return false;
     }
 
-    let selectables = map[name];
-    const starSelectables = map['*'];
+    let selectables = map.get(name);
+    const starSelectables = map.get('*');
     if (starSelectables) {
       selectables = selectables.concat(starSelectables);
     }
@@ -316,13 +316,13 @@ export class SelectorMatcher {
 
   /** @internal */
   _matchPartial(
-      map: {[k: string]: SelectorMatcher}, name: string, cssSelector: CssSelector,
+      map: Map<string, SelectorMatcher>, name: string, cssSelector: CssSelector,
       matchedCallback: (c: CssSelector, a: any) => void): boolean {
     if (!map || typeof name !== 'string') {
       return false;
     }
 
-    const nestedSelector = map[name];
+    const nestedSelector = map.get(name);
     if (!nestedSelector) {
       return false;
     }

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

@@ -0,0 +1,439 @@
+/**
+ * @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 {SecurityContext} from '@angular/core';
+
+import {CompileDirectiveMetadata, CompilePipeMetadata} from '../compile_metadata';
+import {AST, ASTWithSource, BindingPipe, EmptyExpr, Interpolation, LiteralPrimitive, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
+import {Parser} from '../expression_parser/parser';
+import {isPresent} from '../facade/lang';
+import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';
+import {mergeNsAndName} from '../ml_parser/tags';
+import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
+import {view_utils} from '../private_import_core';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
+import {CssSelector} from '../selector';
+import {splitAtColon, splitAtPeriod} from '../util';
+
+import {BoundElementPropertyAst, BoundEventAst, PropertyBindingType, VariableAst} from './template_ast';
+
+const PROPERTY_PARTS_SEPARATOR = '.';
+const ATTRIBUTE_PREFIX = 'attr';
+const CLASS_PREFIX = 'class';
+const STYLE_PREFIX = 'style';
+
+const ANIMATE_PROP_PREFIX = 'animate-';
+
+export enum BoundPropertyType {
+  DEFAULT,
+  LITERAL_ATTR,
+  ANIMATION
+}
+
+/**
+ * Represents a parsed property.
+ */
+export class BoundProperty {
+  constructor(
+      public name: string, public expression: ASTWithSource, public type: BoundPropertyType,
+      public sourceSpan: ParseSourceSpan) {}
+
+  get isLiteral() { return this.type === BoundPropertyType.LITERAL_ATTR; }
+
+  get isAnimation() { return this.type === BoundPropertyType.ANIMATION; }
+}
+
+/**
+ * Parses bindings in templates and in the directive host area.
+ */
+export class BindingParser {
+  pipesByName: Map<string, CompilePipeMetadata> = new Map();
+
+  constructor(
+      private _exprParser: Parser, private _interpolationConfig: InterpolationConfig,
+      private _schemaRegistry: ElementSchemaRegistry, pipes: CompilePipeMetadata[],
+      private _targetErrors: ParseError[]) {
+    pipes.forEach(pipe => this.pipesByName.set(pipe.name, pipe));
+  }
+
+  createDirectiveHostPropertyAsts(dirMeta: CompileDirectiveMetadata, sourceSpan: ParseSourceSpan):
+      BoundElementPropertyAst[] {
+    if (dirMeta.hostProperties) {
+      const boundProps: BoundProperty[] = [];
+      Object.keys(dirMeta.hostProperties).forEach(propName => {
+        const expression = dirMeta.hostProperties[propName];
+        if (typeof expression === 'string') {
+          this.parsePropertyBinding(propName, expression, true, sourceSpan, [], boundProps);
+        } else {
+          this._reportError(
+              `Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
+              sourceSpan);
+        }
+      });
+      return boundProps.map((prop) => this.createElementPropertyAst(dirMeta.selector, prop));
+    }
+  }
+
+  createDirectiveHostEventAsts(dirMeta: CompileDirectiveMetadata, sourceSpan: ParseSourceSpan):
+      BoundEventAst[] {
+    if (dirMeta.hostListeners) {
+      const targetEventAsts: BoundEventAst[] = [];
+      Object.keys(dirMeta.hostListeners).forEach(propName => {
+        const expression = dirMeta.hostListeners[propName];
+        if (typeof expression === 'string') {
+          this.parseEvent(propName, expression, sourceSpan, [], targetEventAsts);
+        } else {
+          this._reportError(
+              `Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
+              sourceSpan);
+        }
+      });
+      return targetEventAsts;
+    }
+  }
+
+  parseInterpolation(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast = this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig);
+      if (ast) this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      this._checkPipes(ast, sourceSpan);
+      if (ast &&
+          (<Interpolation>ast.ast).expressions.length > view_utils.MAX_INTERPOLATION_VALUES) {
+        throw new Error(
+            `Only support at most ${view_utils.MAX_INTERPOLATION_VALUES} interpolation values!`);
+      }
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  parseInlineTemplateBinding(
+      name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
+      targetProps: BoundProperty[], targetVars: VariableAst[]) {
+    const bindings = this._parseTemplateBindings(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)) {
+        this._parsePropertyAst(
+            binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps);
+      } else {
+        targetMatchableAttrs.push([binding.key, '']);
+        this.parseLiteralAttr(binding.key, null, sourceSpan, targetMatchableAttrs, targetProps);
+      }
+    }
+  }
+
+  private _parseTemplateBindings(value: string, sourceSpan: ParseSourceSpan): TemplateBinding[] {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const bindingsResult = this._exprParser.parseTemplateBindings(value, sourceInfo);
+      this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);
+      bindingsResult.templateBindings.forEach((binding) => {
+        if (isPresent(binding.expression)) {
+          this._checkPipes(binding.expression, sourceSpan);
+        }
+      });
+      bindingsResult.warnings.forEach(
+          (warning) => { this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });
+      return bindingsResult.templateBindings;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return [];
+    }
+  }
+
+  parseLiteralAttr(
+      name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
+      targetProps: BoundProperty[]) {
+    if (_isAnimationLabel(name)) {
+      name = name.substring(1);
+      if (value) {
+        this._reportError(
+            `Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
+                ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`,
+            sourceSpan, ParseErrorLevel.FATAL);
+      }
+      this._parseAnimation(name, value, sourceSpan, targetMatchableAttrs, targetProps);
+    } else {
+      targetProps.push(new BoundProperty(
+          name, this._exprParser.wrapLiteralPrimitive(value, ''), BoundPropertyType.LITERAL_ATTR,
+          sourceSpan));
+    }
+  }
+
+  parsePropertyBinding(
+      name: string, expression: string, isHost: boolean, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    let isAnimationProp = false;
+    if (name.startsWith(ANIMATE_PROP_PREFIX)) {
+      isAnimationProp = true;
+      name = name.substring(ANIMATE_PROP_PREFIX.length);
+    } else if (_isAnimationLabel(name)) {
+      isAnimationProp = true;
+      name = name.substring(1);
+    }
+
+    if (isAnimationProp) {
+      this._parseAnimation(name, expression, sourceSpan, targetMatchableAttrs, targetProps);
+    } else {
+      this._parsePropertyAst(
+          name, this._parseBinding(expression, isHost, sourceSpan), sourceSpan,
+          targetMatchableAttrs, targetProps);
+    }
+  }
+
+  parsePropertyInterpolation(
+      name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
+      targetProps: BoundProperty[]): boolean {
+    const expr = this.parseInterpolation(value, sourceSpan);
+    if (isPresent(expr)) {
+      this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);
+      return true;
+    }
+    return false;
+  }
+
+  private _parsePropertyAst(
+      name: string, ast: ASTWithSource, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    targetMatchableAttrs.push([name, ast.source]);
+    targetProps.push(new BoundProperty(name, ast, BoundPropertyType.DEFAULT, sourceSpan));
+  }
+
+  private _parseAnimation(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetProps: BoundProperty[]) {
+    // This will occur when a @trigger is not paired with an expression.
+    // For animations it is valid to not have an expression since */void
+    // states will be applied by angular when the element is attached/detached
+    const ast = this._parseBinding(expression || 'null', false, sourceSpan);
+    targetMatchableAttrs.push([name, ast.source]);
+    targetProps.push(new BoundProperty(name, ast, BoundPropertyType.ANIMATION, sourceSpan));
+  }
+
+  private _parseBinding(value: string, isHostBinding: boolean, sourceSpan: ParseSourceSpan):
+      ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast = isHostBinding ?
+          this._exprParser.parseSimpleBinding(value, sourceInfo, this._interpolationConfig) :
+          this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig);
+      if (ast) this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      this._checkPipes(ast, sourceSpan);
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  createElementPropertyAst(elementSelector: string, boundProp: BoundProperty):
+      BoundElementPropertyAst {
+    if (boundProp.isAnimation) {
+      return new BoundElementPropertyAst(
+          boundProp.name, PropertyBindingType.Animation, SecurityContext.NONE, false,
+          boundProp.expression, null, boundProp.sourceSpan);
+    }
+
+    let unit: string = null;
+    let bindingType: PropertyBindingType;
+    let boundPropertyName: string;
+    const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
+    let securityContexts: SecurityContext[];
+
+    if (parts.length === 1) {
+      var partValue = parts[0];
+      boundPropertyName = this._schemaRegistry.getMappedPropName(partValue);
+      securityContexts = calcPossibleSecurityContexts(
+          this._schemaRegistry, elementSelector, boundPropertyName, false);
+      bindingType = PropertyBindingType.Property;
+      this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);
+    } else {
+      if (parts[0] == ATTRIBUTE_PREFIX) {
+        boundPropertyName = parts[1];
+        this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
+        securityContexts = calcPossibleSecurityContexts(
+            this._schemaRegistry, elementSelector, boundPropertyName, true);
+
+        const nsSeparatorIdx = boundPropertyName.indexOf(':');
+        if (nsSeparatorIdx > -1) {
+          const ns = boundPropertyName.substring(0, nsSeparatorIdx);
+          const name = boundPropertyName.substring(nsSeparatorIdx + 1);
+          boundPropertyName = mergeNsAndName(ns, name);
+        }
+
+        bindingType = PropertyBindingType.Attribute;
+      } else if (parts[0] == CLASS_PREFIX) {
+        boundPropertyName = parts[1];
+        bindingType = PropertyBindingType.Class;
+        securityContexts = [SecurityContext.NONE];
+      } else if (parts[0] == STYLE_PREFIX) {
+        unit = parts.length > 2 ? parts[2] : null;
+        boundPropertyName = parts[1];
+        bindingType = PropertyBindingType.Style;
+        securityContexts = [SecurityContext.STYLE];
+      } else {
+        this._reportError(`Invalid property name '${boundProp.name}'`, boundProp.sourceSpan);
+        bindingType = null;
+        securityContexts = [];
+      }
+    }
+    return new BoundElementPropertyAst(
+        boundPropertyName, bindingType, securityContexts.length === 1 ? securityContexts[0] : null,
+        securityContexts.length > 1, boundProp.expression, unit, boundProp.sourceSpan);
+  }
+
+  parseEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
+    if (_isAnimationLabel(name)) {
+      name = name.substr(1);
+      this._parseAnimationEvent(name, expression, sourceSpan, targetEvents);
+    } else {
+      this._parseEvent(name, expression, sourceSpan, targetMatchableAttrs, targetEvents);
+    }
+  }
+
+  private _parseAnimationEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetEvents: BoundEventAst[]) {
+    const matches = splitAtPeriod(name, [name, '']);
+    const eventName = matches[0];
+    const phase = matches[1].toLowerCase();
+    if (phase) {
+      switch (phase) {
+        case 'start':
+        case 'done':
+          const ast = this._parseAction(expression, sourceSpan);
+          targetEvents.push(new BoundEventAst(eventName, null, phase, ast, sourceSpan));
+          break;
+
+        default:
+          this._reportError(
+              `The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`,
+              sourceSpan);
+          break;
+      }
+    } else {
+      this._reportError(
+          `The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`,
+          sourceSpan);
+    }
+  }
+
+  private _parseEvent(
+      name: string, expression: string, sourceSpan: ParseSourceSpan,
+      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
+    // long format: 'target: eventName'
+    const [target, eventName] = splitAtColon(name, [null, name]);
+    const ast = this._parseAction(expression, sourceSpan);
+    targetMatchableAttrs.push([name, ast.source]);
+    targetEvents.push(new BoundEventAst(eventName, target, null, ast, sourceSpan));
+    // Don't detect directives for event names for now,
+    // so don't add the event name to the matchableAttrs
+  }
+
+  private _parseAction(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
+    const sourceInfo = sourceSpan.start.toString();
+
+    try {
+      const ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig);
+      if (ast) {
+        this._reportExpressionParserErrors(ast.errors, sourceSpan);
+      }
+      if (!ast || ast.ast instanceof EmptyExpr) {
+        this._reportError(`Empty expressions are not allowed`, sourceSpan);
+        return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+      }
+      this._checkPipes(ast, sourceSpan);
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+    }
+  }
+
+  private _reportError(
+      message: string, sourceSpan: ParseSourceSpan,
+      level: ParseErrorLevel = ParseErrorLevel.FATAL) {
+    this._targetErrors.push(new ParseError(sourceSpan, message, level));
+  }
+
+  private _reportExpressionParserErrors(errors: ParserError[], sourceSpan: ParseSourceSpan) {
+    for (const error of errors) {
+      this._reportError(error.message, sourceSpan);
+    }
+  }
+
+  private _checkPipes(ast: ASTWithSource, sourceSpan: ParseSourceSpan) {
+    if (isPresent(ast)) {
+      const collector = new PipeCollector();
+      ast.visit(collector);
+      collector.pipes.forEach((pipeName) => {
+        if (!this.pipesByName.has(pipeName)) {
+          this._reportError(`The pipe '${pipeName}' could not be found`, sourceSpan);
+        }
+      });
+    }
+  }
+
+  /**
+   * @param propName the name of the property / attribute
+   * @param sourceSpan
+   * @param isAttr true when binding to an attribute
+   * @private
+   */
+  private _validatePropertyOrAttributeName(
+      propName: string, sourceSpan: ParseSourceSpan, isAttr: boolean): void {
+    const report = isAttr ? this._schemaRegistry.validateAttribute(propName) :
+                            this._schemaRegistry.validateProperty(propName);
+    if (report.error) {
+      this._reportError(report.msg, sourceSpan, ParseErrorLevel.FATAL);
+    }
+  }
+}
+
+export class PipeCollector extends RecursiveAstVisitor {
+  pipes = new Set<string>();
+  visitPipe(ast: BindingPipe, context: any): any {
+    this.pipes.add(ast.name);
+    ast.exp.visit(this);
+    this.visitAll(ast.args, context);
+    return null;
+  }
+}
+
+function _isAnimationLabel(name: string): boolean {
+  return name[0] == '@';
+}
+
+export function calcPossibleSecurityContexts(
+    registry: ElementSchemaRegistry, selector: string, propName: string,
+    isAttribute: boolean): SecurityContext[] {
+  const ctxs: SecurityContext[] = [];
+  CssSelector.parse(selector).forEach((selector) => {
+    const elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();
+    const notElementNames =
+        new Set(selector.notSelectors.filter(selector => selector.isElementSelector())
+                    .map((selector) => selector.element));
+    const possibleElementNames =
+        elementNames.filter(elementName => !notElementNames.has(elementName));
+
+    ctxs.push(...possibleElementNames.map(
+        elementName => registry.securityContext(elementName, propName, isAttribute)));
+  });
+  return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();
+}

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

@@ -63,8 +63,8 @@ export class AttrAst implements TemplateAst {
 export class BoundElementPropertyAst implements TemplateAst {
   constructor(
       public name: string, public type: PropertyBindingType,
-      public securityContext: SecurityContext, public value: AST, public unit: string,
-      public sourceSpan: ParseSourceSpan) {}
+      public securityContext: SecurityContext, public needsRuntimeSecurityContext: boolean,
+      public value: AST, public unit: string, public sourceSpan: ParseSourceSpan) {}
   visit(visitor: TemplateAstVisitor, context: any): any {
     return visitor.visitElementProperty(this, context);
   }

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

@@ -11,7 +11,7 @@ import {Inject, Injectable, OpaqueToken, Optional, SchemaMetadata, SecurityConte
 import {CompileDirectiveMetadata, CompilePipeMetadata, CompileTemplateMetadata, CompileTokenMetadata, removeIdentifierDuplicates} from '../compile_metadata';
 import {AST, ASTWithSource, BindingPipe, EmptyExpr, Interpolation, ParserError, RecursiveAstVisitor, TemplateBinding} from '../expression_parser/ast';
 import {Parser} from '../expression_parser/parser';
-import {isPresent, isString} from '../facade/lang';
+import {isPresent} from '../facade/lang';
 import {I18NHtmlParser} from '../i18n/i18n_html_parser';
 import {Identifiers, identifierToken, resolveIdentifierToken} from '../identifiers';
 import * as html from '../ml_parser/ast';
@@ -20,13 +20,13 @@ import {expandNodes} from '../ml_parser/icu_ast_expander';
 import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {mergeNsAndName, splitNsName} from '../ml_parser/tags';
 import {ParseError, ParseErrorLevel, ParseSourceSpan} from '../parse_util';
-import {Console, MAX_INTERPOLATION_VALUES} from '../private_import_core';
+import {Console, view_utils} from '../private_import_core';
 import {ProviderElementContext, ProviderViewContext} from '../provider_analyzer';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {CssSelector, SelectorMatcher} from '../selector';
 import {isStyleUrlResolvable} from '../style_url_resolver';
-import {splitAtColon, splitAtPeriod} from '../util';
 
+import {BindingParser, BoundProperty} from './binding_parser';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from './template_ast';
 import {PreparsedElementType, preparseElement} from './template_preparser';
 
@@ -56,17 +56,11 @@ const IDENT_BANANA_BOX_IDX = 8;
 const IDENT_PROPERTY_IDX = 9;
 const IDENT_EVENT_IDX = 10;
 
-const ANIMATE_PROP_PREFIX = 'animate-';
 const TEMPLATE_ELEMENT = 'template';
 const TEMPLATE_ATTR = 'template';
 const TEMPLATE_ATTR_PREFIX = '*';
 const CLASS_ATTR = 'class';
 
-const PROPERTY_PARTS_SEPARATOR = '.';
-const ATTRIBUTE_PREFIX = 'attr';
-const CLASS_PREFIX = 'class';
-const STYLE_PREFIX = 'style';
-
 const TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];
 
 /**
@@ -135,11 +129,20 @@ export class TemplateParser {
       const uniqPipes = removeIdentifierDuplicates(pipes);
       const providerViewContext =
           new ProviderViewContext(component, htmlAstWithErrors.rootNodes[0].sourceSpan);
+      let interpolationConfig: InterpolationConfig;
+      if (component.template && component.template.interpolation) {
+        interpolationConfig = {
+          start: component.template.interpolation[0],
+          end: component.template.interpolation[1]
+        };
+      }
+      const bindingParser = new BindingParser(
+          this._exprParser, interpolationConfig, this._schemaRegistry, uniqPipes, errors);
       const parseVisitor = new TemplateParseVisitor(
-          providerViewContext, uniqDirectives, uniqPipes, schemas, this._exprParser,
-          this._schemaRegistry);
+          providerViewContext, uniqDirectives, bindingParser, this._schemaRegistry, schemas,
+          errors);
       result = html.visitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);
-      errors.push(...parseVisitor.errors, ...providerViewContext.errors);
+      errors.push(...providerViewContext.errors);
     } else {
       result = [];
     }
@@ -197,129 +200,18 @@ export class TemplateParser {
 
 class TemplateParseVisitor implements html.Visitor {
   selectorMatcher = new SelectorMatcher();
-  errors: TemplateParseError[] = [];
   directivesIndex = new Map<CompileDirectiveMetadata, number>();
   ngContentCount: number = 0;
-  pipesByName: Map<string, CompilePipeMetadata> = new Map();
-
-  private _interpolationConfig: InterpolationConfig;
 
   constructor(
       public providerViewContext: ProviderViewContext, directives: CompileDirectiveMetadata[],
-      pipes: CompilePipeMetadata[], private _schemas: SchemaMetadata[], private _exprParser: Parser,
-      private _schemaRegistry: ElementSchemaRegistry) {
-    const tempMeta = providerViewContext.component.template;
-
-    if (tempMeta && tempMeta.interpolation) {
-      this._interpolationConfig = {
-        start: tempMeta.interpolation[0],
-        end: tempMeta.interpolation[1]
-      };
-    }
-
+      private _bindingParser: BindingParser, private _schemaRegistry: ElementSchemaRegistry,
+      private _schemas: SchemaMetadata[], private _targetErrors: TemplateParseError[]) {
     directives.forEach((directive: CompileDirectiveMetadata, index: number) => {
       const selector = CssSelector.parse(directive.selector);
       this.selectorMatcher.addSelectables(selector, directive);
       this.directivesIndex.set(directive, index);
     });
-
-    pipes.forEach(pipe => this.pipesByName.set(pipe.name, pipe));
-  }
-
-  private _reportError(
-      message: string, sourceSpan: ParseSourceSpan,
-      level: ParseErrorLevel = ParseErrorLevel.FATAL) {
-    this.errors.push(new TemplateParseError(message, sourceSpan, level));
-  }
-
-  private _reportParserErrors(errors: ParserError[], sourceSpan: ParseSourceSpan) {
-    for (const error of errors) {
-      this._reportError(error.message, sourceSpan);
-    }
-  }
-
-  private _parseInterpolation(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
-    const sourceInfo = sourceSpan.start.toString();
-
-    try {
-      const ast = this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig);
-      if (ast) this._reportParserErrors(ast.errors, sourceSpan);
-      this._checkPipes(ast, sourceSpan);
-      if (isPresent(ast) &&
-          (<Interpolation>ast.ast).expressions.length > MAX_INTERPOLATION_VALUES) {
-        throw new Error(`Only support at most ${MAX_INTERPOLATION_VALUES} interpolation values!`);
-      }
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
-    }
-  }
-
-  private _parseAction(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
-    const sourceInfo = sourceSpan.start.toString();
-
-    try {
-      const ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig);
-      if (ast) {
-        this._reportParserErrors(ast.errors, sourceSpan);
-      }
-      if (!ast || ast.ast instanceof EmptyExpr) {
-        this._reportError(`Empty expressions are not allowed`, sourceSpan);
-        return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
-      }
-      this._checkPipes(ast, sourceSpan);
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
-    }
-  }
-
-  private _parseBinding(value: string, sourceSpan: ParseSourceSpan): ASTWithSource {
-    const sourceInfo = sourceSpan.start.toString();
-
-    try {
-      const ast = this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig);
-      if (ast) this._reportParserErrors(ast.errors, sourceSpan);
-      this._checkPipes(ast, sourceSpan);
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
-    }
-  }
-
-  private _parseTemplateBindings(value: string, sourceSpan: ParseSourceSpan): TemplateBinding[] {
-    const sourceInfo = sourceSpan.start.toString();
-
-    try {
-      const bindingsResult = this._exprParser.parseTemplateBindings(value, sourceInfo);
-      this._reportParserErrors(bindingsResult.errors, sourceSpan);
-      bindingsResult.templateBindings.forEach((binding) => {
-        if (isPresent(binding.expression)) {
-          this._checkPipes(binding.expression, sourceSpan);
-        }
-      });
-      bindingsResult.warnings.forEach(
-          (warning) => { this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });
-      return bindingsResult.templateBindings;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return [];
-    }
-  }
-
-  private _checkPipes(ast: ASTWithSource, sourceSpan: ParseSourceSpan) {
-    if (isPresent(ast)) {
-      const collector = new PipeCollector();
-      ast.visit(collector);
-      collector.pipes.forEach((pipeName) => {
-        if (!this.pipesByName.has(pipeName)) {
-          this._reportError(`The pipe '${pipeName}' could not be found`, sourceSpan);
-        }
-      });
-    }
   }
 
   visitExpansion(expansion: html.Expansion, context: any): any { return null; }
@@ -328,7 +220,7 @@ class TemplateParseVisitor implements html.Visitor {
 
   visitText(text: html.Text, parent: ElementContext): any {
     const ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
-    const expr = this._parseInterpolation(text.value, text.sourceSpan);
+    const expr = this._bindingParser.parseInterpolation(text.value, text.sourceSpan);
     if (isPresent(expr)) {
       return new BoundTextAst(expr, ngContentIndex, text.sourceSpan);
     } else {
@@ -360,13 +252,12 @@ class TemplateParseVisitor implements html.Visitor {
     }
 
     const matchableAttrs: string[][] = [];
-    const elementOrDirectiveProps: BoundElementOrDirectiveProperty[] = [];
+    const elementOrDirectiveProps: BoundProperty[] = [];
     const elementOrDirectiveRefs: ElementOrDirectiveRef[] = [];
     const elementVars: VariableAst[] = [];
-    const animationProps: BoundElementPropertyAst[] = [];
     const events: BoundEventAst[] = [];
 
-    const templateElementOrDirectiveProps: BoundElementOrDirectiveProperty[] = [];
+    const templateElementOrDirectiveProps: BoundProperty[] = [];
     const templateMatchableAttrs: string[][] = [];
     const templateElementVars: VariableAst[] = [];
 
@@ -377,16 +268,27 @@ class TemplateParseVisitor implements html.Visitor {
 
     element.attrs.forEach(attr => {
       const hasBinding = this._parseAttr(
-          isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, animationProps, events,
+          isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events,
           elementOrDirectiveRefs, elementVars);
 
-      const hasTemplateBinding = this._parseInlineTemplateBinding(
-          attr, templateMatchableAttrs, templateElementOrDirectiveProps, templateElementVars);
-
-      if (hasTemplateBinding && hasInlineTemplates) {
-        this._reportError(
-            `Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with *`,
-            attr.sourceSpan);
+      let templateBindingsSource: string;
+      if (this._normalizeAttributeName(attr.name) == TEMPLATE_ATTR) {
+        templateBindingsSource = attr.value;
+      } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
+        const key = attr.name.substring(TEMPLATE_ATTR_PREFIX.length);  // remove the star
+        templateBindingsSource = (attr.value.length == 0) ? key : key + ' ' + attr.value;
+      }
+      const hasTemplateBinding = isPresent(templateBindingsSource);
+      if (hasTemplateBinding) {
+        if (hasInlineTemplates) {
+          this._reportError(
+              `Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with *`,
+              attr.sourceSpan);
+        }
+        hasInlineTemplates = true;
+        this._bindingParser.parseInlineTemplateBinding(
+            attr.name, templateBindingsSource, attr.sourceSpan, templateMatchableAttrs,
+            templateElementOrDirectiveProps, templateElementVars);
       }
 
       if (!hasBinding && !hasTemplateBinding) {
@@ -394,10 +296,6 @@ class TemplateParseVisitor implements html.Visitor {
         attrs.push(this.visitAttribute(attr, null));
         matchableAttrs.push([attr.name, attr.value]);
       }
-
-      if (hasTemplateBinding) {
-        hasInlineTemplates = true;
-      }
     });
 
     const elementCssSelector = createElementCssSelector(nodeName, matchableAttrs);
@@ -408,8 +306,7 @@ class TemplateParseVisitor implements html.Visitor {
         isTemplateElement, element.name, directiveMetas, elementOrDirectiveProps,
         elementOrDirectiveRefs, element.sourceSpan, references);
     const elementProps: BoundElementPropertyAst[] =
-        this._createElementPropertyAsts(element.name, elementOrDirectiveProps, directiveAsts)
-            .concat(animationProps);
+        this._createElementPropertyAsts(element.name, elementOrDirectiveProps, directiveAsts);
     const isViewRoot = parent.isTemplateElement || hasInlineTemplates;
     const providerContext = new ProviderElementContext(
         this.providerViewContext, parent.providerContext, isViewRoot, directiveAsts, attrs,
@@ -518,39 +415,9 @@ class TemplateParseVisitor implements html.Visitor {
     });
   }
 
-  private _parseInlineTemplateBinding(
-      attr: html.Attribute, targetMatchableAttrs: string[][],
-      targetProps: BoundElementOrDirectiveProperty[], targetVars: VariableAst[]): boolean {
-    let templateBindingsSource: string = null;
-    if (this._normalizeAttributeName(attr.name) == TEMPLATE_ATTR) {
-      templateBindingsSource = attr.value;
-    } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
-      const key = attr.name.substring(TEMPLATE_ATTR_PREFIX.length);  // remove the star
-      templateBindingsSource = (attr.value.length == 0) ? key : key + ' ' + attr.value;
-    }
-    if (isPresent(templateBindingsSource)) {
-      const bindings = this._parseTemplateBindings(templateBindingsSource, attr.sourceSpan);
-      for (let i = 0; i < bindings.length; i++) {
-        const binding = bindings[i];
-        if (binding.keyIsVar) {
-          targetVars.push(new VariableAst(binding.key, binding.name, attr.sourceSpan));
-        } else if (isPresent(binding.expression)) {
-          this._parsePropertyAst(
-              binding.key, binding.expression, attr.sourceSpan, targetMatchableAttrs, targetProps);
-        } else {
-          targetMatchableAttrs.push([binding.key, '']);
-          this._parseLiteralAttr(binding.key, null, attr.sourceSpan, targetProps);
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
   private _parseAttr(
       isTemplateElement: boolean, attr: html.Attribute, targetMatchableAttrs: string[][],
-      targetProps: BoundElementOrDirectiveProperty[],
-      targetAnimationProps: BoundElementPropertyAst[], targetEvents: BoundEventAst[],
+      targetProps: BoundProperty[], targetEvents: BoundEventAst[],
       targetRefs: ElementOrDirectiveRef[], targetVars: VariableAst[]): boolean {
     const name = this._normalizeAttributeName(attr.name);
     const value = attr.value;
@@ -562,9 +429,8 @@ class TemplateParseVisitor implements html.Visitor {
     if (bindParts !== null) {
       hasBinding = true;
       if (isPresent(bindParts[KW_BIND_IDX])) {
-        this._parsePropertyOrAnimation(
-            bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetProps,
-            targetAnimationProps);
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);
 
       } else if (bindParts[KW_LET_IDX]) {
         if (isTemplateElement) {
@@ -579,48 +445,42 @@ class TemplateParseVisitor implements html.Visitor {
         this._parseReference(identifier, value, srcSpan, targetRefs);
 
       } else if (bindParts[KW_ON_IDX]) {
-        this._parseEventOrAnimationEvent(
+        this._bindingParser.parseEvent(
             bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
 
       } else if (bindParts[KW_BINDON_IDX]) {
-        this._parsePropertyOrAnimation(
-            bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetProps,
-            targetAnimationProps);
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);
         this._parseAssignmentEvent(
             bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
 
       } else if (bindParts[KW_AT_IDX]) {
-        if (_isAnimationLabel(name) && isPresent(value) && value.length > 0) {
-          this._reportError(
-              `Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
-                  ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`,
-              srcSpan, ParseErrorLevel.FATAL);
-        }
-        this._parseAnimation(
-            bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetAnimationProps);
+        this._bindingParser.parseLiteralAttr(
+            name, value, srcSpan, targetMatchableAttrs, targetProps);
+
       } else if (bindParts[IDENT_BANANA_BOX_IDX]) {
-        this._parsePropertyOrAnimation(
-            bindParts[IDENT_BANANA_BOX_IDX], value, srcSpan, targetMatchableAttrs, targetProps,
-            targetAnimationProps);
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_BANANA_BOX_IDX], value, false, srcSpan, targetMatchableAttrs,
+            targetProps);
         this._parseAssignmentEvent(
             bindParts[IDENT_BANANA_BOX_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
 
       } else if (bindParts[IDENT_PROPERTY_IDX]) {
-        this._parsePropertyOrAnimation(
-            bindParts[IDENT_PROPERTY_IDX], value, srcSpan, targetMatchableAttrs, targetProps,
-            targetAnimationProps);
+        this._bindingParser.parsePropertyBinding(
+            bindParts[IDENT_PROPERTY_IDX], value, false, srcSpan, targetMatchableAttrs,
+            targetProps);
 
       } else if (bindParts[IDENT_EVENT_IDX]) {
-        this._parseEventOrAnimationEvent(
+        this._bindingParser.parseEvent(
             bindParts[IDENT_EVENT_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);
       }
     } else {
-      hasBinding =
-          this._parsePropertyInterpolation(name, value, srcSpan, targetMatchableAttrs, targetProps);
+      hasBinding = this._bindingParser.parsePropertyInterpolation(
+          name, value, srcSpan, targetMatchableAttrs, targetProps);
     }
 
     if (!hasBinding) {
-      this._parseLiteralAttr(name, value, srcSpan, targetProps);
+      this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps);
     }
 
     return hasBinding;
@@ -649,127 +509,13 @@ class TemplateParseVisitor implements html.Visitor {
     targetRefs.push(new ElementOrDirectiveRef(identifier, value, sourceSpan));
   }
 
-  private _parsePropertyOrAnimation(
-      name: string, expression: string, sourceSpan: ParseSourceSpan,
-      targetMatchableAttrs: string[][], targetProps: BoundElementOrDirectiveProperty[],
-      targetAnimationProps: BoundElementPropertyAst[]) {
-    const animatePropLength = ANIMATE_PROP_PREFIX.length;
-    var isAnimationProp = _isAnimationLabel(name);
-    var animationPrefixLength = 1;
-    if (name.substring(0, animatePropLength) == ANIMATE_PROP_PREFIX) {
-      isAnimationProp = true;
-      animationPrefixLength = animatePropLength;
-    }
-
-    if (isAnimationProp) {
-      this._parseAnimation(
-          name.substr(animationPrefixLength), expression, sourceSpan, targetMatchableAttrs,
-          targetAnimationProps);
-    } else {
-      this._parsePropertyAst(
-          name, this._parseBinding(expression, sourceSpan), sourceSpan, targetMatchableAttrs,
-          targetProps);
-    }
-  }
-
-  private _parseAnimation(
-      name: string, expression: string, sourceSpan: ParseSourceSpan,
-      targetMatchableAttrs: string[][], targetAnimationProps: BoundElementPropertyAst[]) {
-    // This will occur when a @trigger is not paired with an expression.
-    // For animations it is valid to not have an expression since */void
-    // states will be applied by angular when the element is attached/detached
-    if (!isPresent(expression) || expression.length == 0) {
-      expression = 'null';
-    }
-
-    const ast = this._parseBinding(expression, sourceSpan);
-    targetMatchableAttrs.push([name, ast.source]);
-    targetAnimationProps.push(new BoundElementPropertyAst(
-        name, PropertyBindingType.Animation, SecurityContext.NONE, ast, null, sourceSpan));
-  }
-
-  private _parsePropertyInterpolation(
-      name: string, value: string, sourceSpan: ParseSourceSpan, targetMatchableAttrs: string[][],
-      targetProps: BoundElementOrDirectiveProperty[]): boolean {
-    const expr = this._parseInterpolation(value, sourceSpan);
-    if (isPresent(expr)) {
-      this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);
-      return true;
-    }
-    return false;
-  }
-
-  private _parsePropertyAst(
-      name: string, ast: ASTWithSource, sourceSpan: ParseSourceSpan,
-      targetMatchableAttrs: string[][], targetProps: BoundElementOrDirectiveProperty[]) {
-    targetMatchableAttrs.push([name, ast.source]);
-    targetProps.push(new BoundElementOrDirectiveProperty(name, ast, false, sourceSpan));
-  }
-
   private _parseAssignmentEvent(
       name: string, expression: string, sourceSpan: ParseSourceSpan,
       targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
-    this._parseEventOrAnimationEvent(
+    this._bindingParser.parseEvent(
         `${name}Change`, `${expression}=$event`, sourceSpan, targetMatchableAttrs, targetEvents);
   }
 
-  private _parseEventOrAnimationEvent(
-      name: string, expression: string, sourceSpan: ParseSourceSpan,
-      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
-    if (_isAnimationLabel(name)) {
-      name = name.substr(1);
-      this._parseAnimationEvent(name, expression, sourceSpan, targetEvents);
-    } else {
-      this._parseEvent(name, expression, sourceSpan, targetMatchableAttrs, targetEvents);
-    }
-  }
-
-  private _parseAnimationEvent(
-      name: string, expression: string, sourceSpan: ParseSourceSpan,
-      targetEvents: BoundEventAst[]) {
-    const matches = splitAtPeriod(name, [name, '']);
-    const eventName = matches[0];
-    const phase = matches[1].toLowerCase();
-    if (phase) {
-      switch (phase) {
-        case 'start':
-        case 'done':
-          const ast = this._parseAction(expression, sourceSpan);
-          targetEvents.push(new BoundEventAst(eventName, null, phase, ast, sourceSpan));
-          break;
-
-        default:
-          this._reportError(
-              `The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`,
-              sourceSpan);
-          break;
-      }
-    } else {
-      this._reportError(
-          `The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`,
-          sourceSpan);
-    }
-  }
-
-  private _parseEvent(
-      name: string, expression: string, sourceSpan: ParseSourceSpan,
-      targetMatchableAttrs: string[][], targetEvents: BoundEventAst[]) {
-    // long format: 'target: eventName'
-    const [target, eventName] = splitAtColon(name, [null, name]);
-    const ast = this._parseAction(expression, sourceSpan);
-    targetMatchableAttrs.push([name, ast.source]);
-    targetEvents.push(new BoundEventAst(eventName, target, null, ast, sourceSpan));
-    // Don't detect directives for event names for now,
-    // so don't add the event name to the matchableAttrs
-  }
-
-  private _parseLiteralAttr(
-      name: string, value: string, sourceSpan: ParseSourceSpan,
-      targetProps: BoundElementOrDirectiveProperty[]) {
-    targetProps.push(new BoundElementOrDirectiveProperty(
-        name, this._exprParser.wrapLiteralPrimitive(value, ''), true, sourceSpan));
-  }
-
   private _parseDirectives(selectorMatcher: SelectorMatcher, elementCssSelector: CssSelector):
       {directives: CompileDirectiveMetadata[], matchElement: boolean} {
     // Need to sort the directives so that we get consistent results throughout,
@@ -792,7 +538,7 @@ class TemplateParseVisitor implements html.Visitor {
 
   private _createDirectiveAsts(
       isTemplateElement: boolean, elementName: string, directives: CompileDirectiveMetadata[],
-      props: BoundElementOrDirectiveProperty[], elementOrDirectiveRefs: ElementOrDirectiveRef[],
+      props: BoundProperty[], elementOrDirectiveRefs: ElementOrDirectiveRef[],
       elementSourceSpan: ParseSourceSpan, targetReferences: ReferenceAst[]): DirectiveAst[] {
     const matchedReferences = new Set<string>();
     let component: CompileDirectiveMetadata = null;
@@ -802,12 +548,13 @@ class TemplateParseVisitor implements html.Visitor {
       if (directive.isComponent) {
         component = directive;
       }
-      const hostProperties: BoundElementPropertyAst[] = [];
-      const hostEvents: BoundEventAst[] = [];
       const directiveProperties: BoundDirectivePropertyAst[] = [];
-      this._createDirectiveHostPropertyAsts(
-          elementName, directive.hostProperties, sourceSpan, hostProperties);
-      this._createDirectiveHostEventAsts(directive.hostListeners, sourceSpan, hostEvents);
+      const hostProperties =
+          this._bindingParser.createDirectiveHostPropertyAsts(directive, sourceSpan);
+      // Note: We need to check the host properties here as well,
+      // as we don't know the element name in the DirectiveWrapperCompiler yet.
+      this._checkPropertiesInSchema(elementName, hostProperties);
+      const hostEvents = this._bindingParser.createDirectiveHostEventAsts(directive, sourceSpan);
       this._createDirectivePropertyAsts(directive.inputs, props, directiveProperties);
       elementOrDirectiveRefs.forEach((elOrDirRef) => {
         if ((elOrDirRef.value.length === 0 && directive.isComponent) ||
@@ -838,47 +585,11 @@ class TemplateParseVisitor implements html.Visitor {
     return directiveAsts;
   }
 
-  private _createDirectiveHostPropertyAsts(
-      elementName: string, hostProps: {[key: string]: string}, sourceSpan: ParseSourceSpan,
-      targetPropertyAsts: BoundElementPropertyAst[]) {
-    if (hostProps) {
-      Object.keys(hostProps).forEach(propName => {
-        const expression = hostProps[propName];
-        if (isString(expression)) {
-          const exprAst = this._parseBinding(expression, sourceSpan);
-          targetPropertyAsts.push(
-              this._createElementPropertyAst(elementName, propName, exprAst, sourceSpan));
-        } else {
-          this._reportError(
-              `Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
-              sourceSpan);
-        }
-      });
-    }
-  }
-
-  private _createDirectiveHostEventAsts(
-      hostListeners: {[key: string]: string}, sourceSpan: ParseSourceSpan,
-      targetEventAsts: BoundEventAst[]) {
-    if (hostListeners) {
-      Object.keys(hostListeners).forEach(propName => {
-        const expression = hostListeners[propName];
-        if (isString(expression)) {
-          this._parseEventOrAnimationEvent(propName, expression, sourceSpan, [], targetEventAsts);
-        } else {
-          this._reportError(
-              `Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`,
-              sourceSpan);
-        }
-      });
-    }
-  }
-
   private _createDirectivePropertyAsts(
-      directiveProperties: {[key: string]: string}, boundProps: BoundElementOrDirectiveProperty[],
+      directiveProperties: {[key: string]: string}, boundProps: BoundProperty[],
       targetBoundDirectiveProps: BoundDirectivePropertyAst[]) {
     if (directiveProperties) {
-      const boundPropsByName = new Map<string, BoundElementOrDirectiveProperty>();
+      const boundPropsByName = new Map<string, BoundProperty>();
       boundProps.forEach(boundProp => {
         const prevValue = boundPropsByName.get(boundProp.name);
         if (!prevValue || prevValue.isLiteral) {
@@ -901,7 +612,7 @@ class TemplateParseVisitor implements html.Visitor {
   }
 
   private _createElementPropertyAsts(
-      elementName: string, props: BoundElementOrDirectiveProperty[],
+      elementName: string, props: BoundProperty[],
       directives: DirectiveAst[]): BoundElementPropertyAst[] {
     const boundElementProps: BoundElementPropertyAst[] = [];
     const boundDirectivePropsIndex = new Map<string, BoundDirectivePropertyAst>();
@@ -912,98 +623,15 @@ class TemplateParseVisitor implements html.Visitor {
       });
     });
 
-    props.forEach((prop: BoundElementOrDirectiveProperty) => {
+    props.forEach((prop: BoundProperty) => {
       if (!prop.isLiteral && !boundDirectivePropsIndex.get(prop.name)) {
-        boundElementProps.push(this._createElementPropertyAst(
-            elementName, prop.name, prop.expression, prop.sourceSpan));
+        boundElementProps.push(this._bindingParser.createElementPropertyAst(elementName, prop));
       }
     });
+    this._checkPropertiesInSchema(elementName, boundElementProps);
     return boundElementProps;
   }
 
-  private _createElementPropertyAst(
-      elementName: string, name: string, ast: AST,
-      sourceSpan: ParseSourceSpan): BoundElementPropertyAst {
-    let unit: string = null;
-    let bindingType: PropertyBindingType;
-    let boundPropertyName: string;
-    const parts = name.split(PROPERTY_PARTS_SEPARATOR);
-    let securityContext: SecurityContext;
-
-    if (parts.length === 1) {
-      var partValue = parts[0];
-      if (_isAnimationLabel(partValue)) {
-        boundPropertyName = partValue.substr(1);
-        bindingType = PropertyBindingType.Animation;
-        securityContext = SecurityContext.NONE;
-      } else {
-        boundPropertyName = this._schemaRegistry.getMappedPropName(partValue);
-        securityContext = this._schemaRegistry.securityContext(elementName, boundPropertyName);
-        bindingType = PropertyBindingType.Property;
-        this._validatePropertyOrAttributeName(boundPropertyName, sourceSpan, false);
-        if (!this._schemaRegistry.hasProperty(elementName, boundPropertyName, this._schemas)) {
-          let errorMsg =
-              `Can't bind to '${boundPropertyName}' since it isn't a known property of '${elementName}'.`;
-          if (elementName.indexOf('-') > -1) {
-            errorMsg +=
-                `\n1. If '${elementName}' is an Angular component and it has '${boundPropertyName}' input, then verify that it is part of this module.` +
-                `\n2. If '${elementName}' is a Web Component then add "CUSTOM_ELEMENTS_SCHEMA" to the '@NgModule.schemas' of this component to suppress this message.\n`;
-          }
-          this._reportError(errorMsg, sourceSpan);
-        }
-      }
-    } else {
-      if (parts[0] == ATTRIBUTE_PREFIX) {
-        boundPropertyName = parts[1];
-        this._validatePropertyOrAttributeName(boundPropertyName, sourceSpan, true);
-        // NB: For security purposes, use the mapped property name, not the attribute name.
-        const mapPropName = this._schemaRegistry.getMappedPropName(boundPropertyName);
-        securityContext = this._schemaRegistry.securityContext(elementName, mapPropName);
-
-        const nsSeparatorIdx = boundPropertyName.indexOf(':');
-        if (nsSeparatorIdx > -1) {
-          const ns = boundPropertyName.substring(0, nsSeparatorIdx);
-          const name = boundPropertyName.substring(nsSeparatorIdx + 1);
-          boundPropertyName = mergeNsAndName(ns, name);
-        }
-
-        bindingType = PropertyBindingType.Attribute;
-      } else if (parts[0] == CLASS_PREFIX) {
-        boundPropertyName = parts[1];
-        bindingType = PropertyBindingType.Class;
-        securityContext = SecurityContext.NONE;
-      } else if (parts[0] == STYLE_PREFIX) {
-        unit = parts.length > 2 ? parts[2] : null;
-        boundPropertyName = parts[1];
-        bindingType = PropertyBindingType.Style;
-        securityContext = SecurityContext.STYLE;
-      } else {
-        this._reportError(`Invalid property name '${name}'`, sourceSpan);
-        bindingType = null;
-        securityContext = null;
-      }
-    }
-
-    return new BoundElementPropertyAst(
-        boundPropertyName, bindingType, securityContext, ast, unit, sourceSpan);
-  }
-
-
-  /**
-   * @param propName the name of the property / attribute
-   * @param sourceSpan
-   * @param isAttr true when binding to an attribute
-   * @private
-   */
-  private _validatePropertyOrAttributeName(
-      propName: string, sourceSpan: ParseSourceSpan, isAttr: boolean): void {
-    const report = isAttr ? this._schemaRegistry.validateAttribute(propName) :
-                            this._schemaRegistry.validateProperty(propName);
-    if (report.error) {
-      this._reportError(report.msg, sourceSpan, ParseErrorLevel.FATAL);
-    }
-  }
-
   private _findComponentDirectives(directives: DirectiveAst[]): DirectiveAst[] {
     return directives.filter(directive => directive.directive.isComponent);
   }
@@ -1074,6 +702,28 @@ class TemplateParseVisitor implements html.Visitor {
       }
     });
   }
+
+  private _checkPropertiesInSchema(elementName: string, boundProps: BoundElementPropertyAst[]) {
+    boundProps.forEach((boundProp) => {
+      if (boundProp.type === PropertyBindingType.Property &&
+          !this._schemaRegistry.hasProperty(elementName, boundProp.name, this._schemas)) {
+        let errorMsg =
+            `Can't bind to '${boundProp.name}' since it isn't a known property of '${elementName}'.`;
+        if (elementName.indexOf('-') > -1) {
+          errorMsg +=
+              `\n1. If '${elementName}' is an Angular component and it has '${boundProp.name}' input, then verify that it is part of this module.` +
+              `\n2. If '${elementName}' is a Web Component then add "CUSTOM_ELEMENTS_SCHEMA" to the '@NgModule.schemas' of this component to suppress this message.\n`;
+        }
+        this._reportError(errorMsg, boundProp.sourceSpan);
+      }
+    });
+  }
+
+  private _reportError(
+      message: string, sourceSpan: ParseSourceSpan,
+      level: ParseErrorLevel = ParseErrorLevel.FATAL) {
+    this._targetErrors.push(new ParseError(sourceSpan, message, level));
+  }
 }
 
 class NonBindableVisitor implements html.Visitor {
@@ -1112,12 +762,6 @@ class NonBindableVisitor implements html.Visitor {
   visitExpansionCase(expansionCase: html.ExpansionCase, context: any): any { return expansionCase; }
 }
 
-class BoundElementOrDirectiveProperty {
-  constructor(
-      public name: string, public expression: AST, public isLiteral: boolean,
-      public sourceSpan: ParseSourceSpan) {}
-}
-
 class ElementOrDirectiveRef {
   constructor(public name: string, public value: string, public sourceSpan: ParseSourceSpan) {}
 }
@@ -1185,21 +829,6 @@ function createElementCssSelector(elementName: string, matchableAttrs: string[][
 const EMPTY_ELEMENT_CONTEXT = new ElementContext(true, new SelectorMatcher(), null, null);
 const NON_BINDABLE_VISITOR = new NonBindableVisitor();
 
-
-export class PipeCollector extends RecursiveAstVisitor {
-  pipes: Set<string> = new Set<string>();
-  visitPipe(ast: BindingPipe, context: any): any {
-    this.pipes.add(ast.name);
-    ast.exp.visit(this);
-    this.visitAll(ast.args, context);
-    return null;
-  }
-}
-
-function _isAnimationLabel(name: string): boolean {
-  return name[0] == '@';
-}
-
 function _isEmptyTextNode(node: html.Node): boolean {
   return node instanceof html.Text && node.value.trim().length == 0;
 }

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

@@ -6,13 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompileTokenMetadata} from './compile_metadata';
-import {isArray, isBlank, isPresent, isPrimitive, isStrictStringMap} from './facade/lang';
-import * as o from './output/output_ast';
+import {isBlank, isPrimitive, isStrictStringMap} from './facade/lang';
 
 export const MODULE_SUFFIX = '';
 
-var CAMEL_CASE_REGEXP = /([A-Z])/g;
+const CAMEL_CASE_REGEXP = /([A-Z])/g;
 
 export function camelCaseToDashCase(input: string): string {
   return input.replace(CAMEL_CASE_REGEXP, (...m: any[]) => '-' + m[1].toLowerCase());
@@ -37,15 +35,19 @@ export function sanitizeIdentifier(name: string): string {
 }
 
 export function visitValue(value: any, visitor: ValueVisitor, context: any): any {
-  if (isArray(value)) {
+  if (Array.isArray(value)) {
     return visitor.visitArray(<any[]>value, context);
-  } else if (isStrictStringMap(value)) {
-    return visitor.visitStringMap(<{[key: string]: any}>value, context);
-  } else if (isBlank(value) || isPrimitive(value)) {
-    return visitor.visitPrimitive(value, context);
-  } else {
-    return visitor.visitOther(value, context);
   }
+
+  if (isStrictStringMap(value)) {
+    return visitor.visitStringMap(<{[key: string]: any}>value, context);
+  }
+
+  if (isBlank(value) || isPrimitive(value)) {
+    return visitor.visitPrimitive(value, context);
+  }
+
+  return visitor.visitOther(value, context);
 }
 
 export interface ValueVisitor {
@@ -68,25 +70,6 @@ export class ValueTransformer implements ValueVisitor {
   visitOther(value: any, context: any): any { return value; }
 }
 
-export function assetUrl(pkg: string, path: string = null, type: string = 'src'): string {
-  if (path == null) {
-    return `asset:@angular/lib/${pkg}/index`;
-  } else {
-    return `asset:@angular/lib/${pkg}/src/${path}`;
-  }
-}
-
-export function createDiTokenExpression(token: CompileTokenMetadata): o.Expression {
-  if (isPresent(token.value)) {
-    return o.literal(token.value);
-  } else if (token.identifierIsInstance) {
-    return o.importExpr(token.identifier)
-        .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
-  } else {
-    return o.importExpr(token.identifier);
-  }
-}
-
 export class SyncAsyncResult<T> {
   constructor(public syncResult: T, public asyncResult: Promise<T> = null) {
     if (!asyncResult) {

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

@@ -1,15 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {TemplateAst} from '../template_parser/template_ast';
-
-import {CompileNode} from './compile_element';
-
-export class CompileBinding {
-  constructor(public node: CompileNode, public sourceAst: TemplateAst) {}
-}

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

@@ -8,18 +8,20 @@
 
 
 import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileIdentifierMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata} from '../compile_metadata';
-import {ListWrapper, MapWrapper} from '../facade/collection';
+import {createDiTokenExpression} from '../compiler_util/identifier_util';
+import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
+import {MapWrapper} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 import {Identifiers, identifierToken, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
 import * as o from '../output/output_ast';
 import {convertValueToOutputAst} from '../output/value_util';
 import {ProviderAst, ProviderAstType, ReferenceAst, TemplateAst} from '../template_parser/template_ast';
-import {createDiTokenExpression} from '../util';
 
 import {CompileMethod} from './compile_method';
 import {CompileQuery, addQueryToTokenMap, createQueryList} from './compile_query';
 import {CompileView} from './compile_view';
-import {InjectMethodVars} from './constants';
+import {InjectMethodVars, ViewProperties} from './constants';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewFactoryDependency} from './deps';
 import {getPropertyInView, injectFromViewParentInjector} from './util';
 
 export class CompileNode {
@@ -34,7 +36,7 @@ export class CompileNode {
 
 export class CompileElement extends CompileNode {
   static createNull(): CompileElement {
-    return new CompileElement(null, null, null, null, null, null, [], [], false, false, []);
+    return new CompileElement(null, null, null, null, null, null, [], [], false, false, [], []);
   }
 
   private _compViewExpr: o.Expression = null;
@@ -42,6 +44,7 @@ export class CompileElement extends CompileNode {
   public elementRef: o.Expression;
   public injector: o.Expression;
   public instances = new Map<any, o.Expression>();
+  public directiveWrapperInstance = new Map<any, o.Expression>();
   private _resolvedProviders: Map<any, ProviderAst>;
 
   private _queryCount = 0;
@@ -57,7 +60,9 @@ export class CompileElement extends CompileNode {
       sourceAst: TemplateAst, public component: CompileDirectiveMetadata,
       private _directives: CompileDirectiveMetadata[],
       private _resolvedProvidersArray: ProviderAst[], public hasViewContainer: boolean,
-      public hasEmbeddedView: boolean, references: ReferenceAst[]) {
+      public hasEmbeddedView: boolean, references: ReferenceAst[],
+      private _targetDependencies:
+          Array<ViewFactoryDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {
     super(parent, view, nodeIndex, renderNode, sourceAst);
     this.referenceTokens = {};
     references.forEach(ref => this.referenceTokens[ref.name] = ref.value);
@@ -72,6 +77,9 @@ export class CompileElement extends CompileNode {
     if (this.hasViewContainer || this.hasEmbeddedView || isPresent(this.component)) {
       this._createAppElement();
     }
+    if (this.component) {
+      this._createComponentFactoryResolver();
+    }
   }
 
   private _createAppElement() {
@@ -92,7 +100,13 @@ export class CompileElement extends CompileNode {
     this.instances.set(resolveIdentifierToken(Identifiers.AppElement).reference, this.appElement);
   }
 
-  public createComponentFactoryResolver(entryComponents: CompileIdentifierMetadata[]) {
+  private _createComponentFactoryResolver() {
+    let entryComponents =
+        this.component.entryComponents.map((entryComponent: CompileIdentifierMetadata) => {
+          var id = new CompileIdentifierMetadata({name: entryComponent.name});
+          this._targetDependencies.push(new ComponentFactoryDependency(entryComponent, id));
+          return id;
+        });
     if (!entryComponents || entryComponents.length === 0) {
       return;
     }
@@ -155,6 +169,8 @@ export class CompileElement extends CompileNode {
     // create all the provider instances, some in the view constructor,
     // some as getters. We rely on the fact that they are already sorted topologically.
     MapWrapper.values(this._resolvedProviders).forEach((resolvedProvider) => {
+      const isDirectiveWrapper = resolvedProvider.providerType === ProviderAstType.Component ||
+          resolvedProvider.providerType === ProviderAstType.Directive;
       var providerValueExpressions = resolvedProvider.providers.map((provider) => {
         if (isPresent(provider.useExisting)) {
           return this._getDependency(
@@ -167,8 +183,17 @@ export class CompileElement extends CompileNode {
         } else if (isPresent(provider.useClass)) {
           var deps = provider.deps || provider.useClass.diDeps;
           var depsExpr = deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep));
-          return o.importExpr(provider.useClass)
-              .instantiate(depsExpr, o.importType(provider.useClass));
+          if (isDirectiveWrapper) {
+            const directiveWrapperIdentifier = new CompileIdentifierMetadata(
+                {name: DirectiveWrapperCompiler.dirWrapperClassName(provider.useClass)});
+            this._targetDependencies.push(
+                new DirectiveWrapperDependency(provider.useClass, directiveWrapperIdentifier));
+            return o.importExpr(directiveWrapperIdentifier)
+                .instantiate(depsExpr, o.importType(directiveWrapperIdentifier));
+          } else {
+            return o.importExpr(provider.useClass)
+                .instantiate(depsExpr, o.importType(provider.useClass));
+          }
         } else {
           return convertValueToOutputAst(provider.useValue);
         }
@@ -177,7 +202,12 @@ export class CompileElement extends CompileNode {
       var instance = createProviderProperty(
           propName, resolvedProvider, providerValueExpressions, resolvedProvider.multiProvider,
           resolvedProvider.eager, this);
-      this.instances.set(resolvedProvider.token.reference, instance);
+      if (isDirectiveWrapper) {
+        this.directiveWrapperInstance.set(resolvedProvider.token.reference, instance);
+        this.instances.set(resolvedProvider.token.reference, instance.prop('context'));
+      } else {
+        this.instances.set(resolvedProvider.token.reference, instance);
+      }
     });
 
     for (var i = 0; i < this._directives.length; i++) {
@@ -188,9 +218,8 @@ export class CompileElement extends CompileNode {
     var queriesWithReads: _QueryWithRead[] = [];
     MapWrapper.values(this._resolvedProviders).forEach((resolvedProvider) => {
       var queriesForProvider = this._getQueriesFor(resolvedProvider.token);
-      ListWrapper.addAll(
-          queriesWithReads,
-          queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
+      queriesWithReads.push(
+          ...queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
     });
     Object.keys(this.referenceTokens).forEach(varName => {
       var token = this.referenceTokens[varName];
@@ -202,9 +231,8 @@ export class CompileElement extends CompileNode {
       }
       this.view.locals.set(varName, varValue);
       var varToken = new CompileTokenMetadata({value: varName});
-      ListWrapper.addAll(
-          queriesWithReads,
-          this._getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
+      queriesWithReads.push(
+          ...this._getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
     });
     queriesWithReads.forEach((queryWithRead) => {
       var value: o.Expression;
@@ -285,8 +313,7 @@ export class CompileElement extends CompileNode {
     while (!currentEl.isNull()) {
       queries = currentEl._queries.get(token.reference);
       if (isPresent(queries)) {
-        ListWrapper.addAll(
-            result, queries.filter((query) => query.meta.descendants || distance <= 1));
+        result.push(...queries.filter((query) => query.meta.descendants || distance <= 1));
       }
       if (currentEl._directives.length > 0) {
         distance++;
@@ -295,7 +322,7 @@ export class CompileElement extends CompileNode {
     }
     queries = this.view.componentView.viewQueries.get(token.reference);
     if (isPresent(queries)) {
-      ListWrapper.addAll(result, queries);
+      result.push(...queries);
     }
     return result;
   }

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

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ListWrapper} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 import * as o from '../output/output_ast';
 import {TemplateAst} from '../template_parser/template_ast';
@@ -66,6 +65,8 @@ export class CompileMethod {
     this._newState = new _DebugState(nodeIndex, templateAst);
   }
 
+  push(...stmts: o.Statement[]) { this.addStmts(stmts); }
+
   addStmt(stmt: o.Statement) {
     this._updateDebugContextIfNeeded();
     this._bodyStatements.push(stmt);
@@ -73,7 +74,7 @@ export class CompileMethod {
 
   addStmts(stmts: o.Statement[]) {
     this._updateDebugContextIfNeeded();
-    ListWrapper.addAll(this._bodyStatements, stmts);
+    this._bodyStatements.push(...stmts);
   }
 
   finish(): o.Statement[] { return this._bodyStatements; }

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

@@ -8,11 +8,12 @@
 
 
 import {CompilePipeMetadata} from '../compile_metadata';
+import {createPureProxy} from '../compiler_util/identifier_util';
 import {Identifiers, resolveIdentifier, resolveIdentifierToken} from '../identifiers';
 import * as o from '../output/output_ast';
 
 import {CompileView} from './compile_view';
-import {createPureProxy, getPropertyInView, injectFromViewParentInjector} from './util';
+import {getPropertyInView, injectFromViewParentInjector} from './util';
 
 export class CompilePipe {
   static call(view: CompileView, name: string, args: o.Expression[]): o.Expression {
@@ -65,7 +66,8 @@ export class CompilePipe {
       createPureProxy(
           pipeInstanceSeenFromPureProxy.prop('transform')
               .callMethod(o.BuiltinMethod.Bind, [pipeInstanceSeenFromPureProxy]),
-          args.length, purePipeProxyInstance, callingView);
+          args.length, purePipeProxyInstance,
+          {fields: callingView.fields, ctorStmts: callingView.createMethod});
       return o.importExpr(resolveIdentifier(Identifiers.castByValue))
           .callFn([purePipeProxyInstance, pipeInstanceSeenFromPureProxy.prop('transform')])
           .callFn(args);

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

@@ -8,21 +8,20 @@
 
 import {AnimationEntryCompileResult} from '../animation/animation_compiler';
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompilePipeMetadata} from '../compile_metadata';
+import {EventHandlerVars, NameResolver} from '../compiler_util/expression_converter';
+import {createPureProxy} from '../compiler_util/identifier_util';
 import {CompilerConfig} from '../config';
-import {ListWrapper, MapWrapper} from '../facade/collection';
+import {MapWrapper} from '../facade/collection';
 import {isPresent} from '../facade/lang';
 import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {ViewType} from '../private_import_core';
 
-import {CompileBinding} from './compile_binding';
 import {CompileElement, CompileNode} from './compile_element';
 import {CompileMethod} from './compile_method';
 import {CompilePipe} from './compile_pipe';
 import {CompileQuery, addQueryToTokenMap, createQueryList} from './compile_query';
-import {EventHandlerVars} from './constants';
-import {NameResolver} from './expression_converter';
-import {createPureProxy, getPropertyInView, getViewFactoryName} from './util';
+import {getPropertyInView, getViewFactoryName} from './util';
 
 export class CompileView implements NameResolver {
   public viewType: ViewType;
@@ -32,9 +31,6 @@ export class CompileView implements NameResolver {
   // root nodes or AppElements for ViewContainers
   public rootNodesOrAppElements: o.Expression[] = [];
 
-  public bindings: CompileBinding[] = [];
-
-  public classStatements: o.Statement[] = [];
   public createMethod: CompileMethod;
   public animationBindingsMethod: CompileMethod;
   public injectorGetMethod: CompileMethod;
@@ -47,8 +43,9 @@ export class CompileView implements NameResolver {
   public afterViewLifecycleCallbacksMethod: CompileMethod;
   public destroyMethod: CompileMethod;
   public detachMethod: CompileMethod;
-  public eventHandlerMethods: o.ClassMethod[] = [];
+  public methods: o.ClassMethod[] = [];
 
+  public ctorStmts: o.Statement[] = [];
   public fields: o.ClassField[] = [];
   public getters: o.ClassGetter[] = [];
   public disposables: o.Expression[] = [];
@@ -102,7 +99,7 @@ export class CompileView implements NameResolver {
     var viewQueries = new Map<any, CompileQuery[]>();
     if (this.viewType === ViewType.COMPONENT) {
       var directiveInstance = o.THIS_EXPR.prop('context');
-      ListWrapper.forEachWithIndex(this.component.viewQueries, (queryMeta, queryIndex) => {
+      this.component.viewQueries.forEach((queryMeta, queryIndex) => {
         var propName = `_viewQuery_${queryMeta.selectors[0].name}_${queryIndex}`;
         var queryList = createQueryList(queryMeta, directiveInstance, propName, this);
         var query = new CompileQuery(queryMeta, queryList, directiveInstance, this);
@@ -149,48 +146,6 @@ export class CompileView implements NameResolver {
     }
   }
 
-  createLiteralArray(values: o.Expression[]): o.Expression {
-    if (values.length === 0) {
-      return o.importExpr(resolveIdentifier(Identifiers.EMPTY_ARRAY));
-    }
-    var proxyExpr = o.THIS_EXPR.prop(`_arr_${this.literalArrayCount++}`);
-    var proxyParams: o.FnParam[] = [];
-    var proxyReturnEntries: o.Expression[] = [];
-    for (var i = 0; i < values.length; i++) {
-      var paramName = `p${i}`;
-      proxyParams.push(new o.FnParam(paramName));
-      proxyReturnEntries.push(o.variable(paramName));
-    }
-    createPureProxy(
-        o.fn(
-            proxyParams, [new o.ReturnStatement(o.literalArr(proxyReturnEntries))],
-            new o.ArrayType(o.DYNAMIC_TYPE)),
-        values.length, proxyExpr, this);
-    return proxyExpr.callFn(values);
-  }
-
-  createLiteralMap(entries: [string, o.Expression][]): o.Expression {
-    if (entries.length === 0) {
-      return o.importExpr(resolveIdentifier(Identifiers.EMPTY_MAP));
-    }
-    const proxyExpr = o.THIS_EXPR.prop(`_map_${this.literalMapCount++}`);
-    const proxyParams: o.FnParam[] = [];
-    const proxyReturnEntries: [string, o.Expression][] = [];
-    const values: o.Expression[] = [];
-    for (var i = 0; i < entries.length; i++) {
-      const paramName = `p${i}`;
-      proxyParams.push(new o.FnParam(paramName));
-      proxyReturnEntries.push([entries[i][0], o.variable(paramName)]);
-      values.push(<o.Expression>entries[i][1]);
-    }
-    createPureProxy(
-        o.fn(
-            proxyParams, [new o.ReturnStatement(o.literalMap(proxyReturnEntries))],
-            new o.MapType(o.DYNAMIC_TYPE)),
-        entries.length, proxyExpr, this);
-    return proxyExpr.callFn(values);
-  }
-
   afterNodes() {
     MapWrapper.values(this.viewQueries)
         .forEach(

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

@@ -9,9 +9,9 @@
 import {ChangeDetectionStrategy, ViewEncapsulation} from '@angular/core';
 
 import {CompileIdentifierMetadata} from '../compile_metadata';
-import {Identifiers, resolveEnumIdentifier, resolveIdentifier} from '../identifiers';
+import {createEnumExpression} from '../compiler_util/identifier_util';
+import {Identifiers, resolveEnumIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
-
 import {ChangeDetectorStatus, ViewType} from '../private_import_core';
 
 function _enumExpression(classIdentifier: CompileIdentifierMetadata, name: string): o.Expression {
@@ -20,69 +20,25 @@ function _enumExpression(classIdentifier: CompileIdentifierMetadata, name: strin
 
 export class ViewTypeEnum {
   static fromValue(value: ViewType): o.Expression {
-    const viewType = resolveIdentifier(Identifiers.ViewType);
-    switch (value) {
-      case ViewType.HOST:
-        return _enumExpression(viewType, 'HOST');
-      case ViewType.COMPONENT:
-        return _enumExpression(viewType, 'COMPONENT');
-      case ViewType.EMBEDDED:
-        return _enumExpression(viewType, 'EMBEDDED');
-      default:
-        throw Error(`Inavlid ViewType value: ${value}`);
-    }
+    return createEnumExpression(Identifiers.ViewType, value);
   }
 }
 
 export class ViewEncapsulationEnum {
   static fromValue(value: ViewEncapsulation): o.Expression {
-    const viewEncapsulation = resolveIdentifier(Identifiers.ViewEncapsulation);
-    switch (value) {
-      case ViewEncapsulation.Emulated:
-        return _enumExpression(viewEncapsulation, 'Emulated');
-      case ViewEncapsulation.Native:
-        return _enumExpression(viewEncapsulation, 'Native');
-      case ViewEncapsulation.None:
-        return _enumExpression(viewEncapsulation, 'None');
-      default:
-        throw Error(`Inavlid ViewEncapsulation value: ${value}`);
-    }
+    return createEnumExpression(Identifiers.ViewEncapsulation, value);
   }
 }
 
 export class ChangeDetectionStrategyEnum {
   static fromValue(value: ChangeDetectionStrategy): o.Expression {
-    const changeDetectionStrategy = resolveIdentifier(Identifiers.ChangeDetectionStrategy);
-    switch (value) {
-      case ChangeDetectionStrategy.OnPush:
-        return _enumExpression(changeDetectionStrategy, 'OnPush');
-      case ChangeDetectionStrategy.Default:
-        return _enumExpression(changeDetectionStrategy, 'Default');
-      default:
-        throw Error(`Inavlid ChangeDetectionStrategy value: ${value}`);
-    }
+    return createEnumExpression(Identifiers.ChangeDetectionStrategy, value);
   }
 }
 
 export class ChangeDetectorStatusEnum {
   static fromValue(value: ChangeDetectorStatusEnum): o.Expression {
-    const changeDetectorStatus = resolveIdentifier(Identifiers.ChangeDetectorStatus);
-    switch (value) {
-      case ChangeDetectorStatus.CheckOnce:
-        return _enumExpression(changeDetectorStatus, 'CheckOnce');
-      case ChangeDetectorStatus.Checked:
-        return _enumExpression(changeDetectorStatus, 'Checked');
-      case ChangeDetectorStatus.CheckAlways:
-        return _enumExpression(changeDetectorStatus, 'CheckAlways');
-      case ChangeDetectorStatus.Detached:
-        return _enumExpression(changeDetectorStatus, 'Detached');
-      case ChangeDetectorStatus.Errored:
-        return _enumExpression(changeDetectorStatus, 'Errored');
-      case ChangeDetectorStatus.Destroyed:
-        return _enumExpression(changeDetectorStatus, 'Destroyed');
-      default:
-        throw Error(`Inavlid ChangeDetectorStatus value: ${value}`);
-    }
+    return createEnumExpression(Identifiers.ChangeDetectorStatus, value);
   }
 }
 
@@ -98,8 +54,6 @@ export class ViewProperties {
   static viewUtils = o.THIS_EXPR.prop('viewUtils');
 }
 
-export class EventHandlerVars { static event = o.variable('$event'); }
-
 export class InjectMethodVars {
   static token = o.variable('token');
   static requestNodeIndex = o.variable('requestNodeIndex');
@@ -110,5 +64,4 @@ export class DetectChangesVars {
   static throwOnChange = o.variable(`throwOnChange`);
   static changes = o.variable(`changes`);
   static changed = o.variable(`changed`);
-  static valUnwrapper = o.variable(`valUnwrapper`);
 }

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {CompileIdentifierMetadata} from '../compile_metadata';
+
+export class ViewFactoryDependency {
+  constructor(
+      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
+}
+
+export class ComponentFactoryDependency {
+  constructor(
+      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
+}
+
+export class DirectiveWrapperDependency {
+  constructor(
+      public dir: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
+}

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

@@ -7,16 +7,15 @@
  */
 
 import {CompileDirectiveMetadata} from '../compile_metadata';
+import {EventHandlerVars, convertActionBinding} from '../compiler_util/expression_converter';
 import {isPresent} from '../facade/lang';
 import {identifierToken} from '../identifiers';
 import * as o from '../output/output_ast';
 import {BoundEventAst, DirectiveAst} from '../template_parser/template_ast';
 
-import {CompileBinding} from './compile_binding';
 import {CompileElement} from './compile_element';
 import {CompileMethod} from './compile_method';
-import {EventHandlerVars, ViewProperties} from './constants';
-import {convertCdStatementToIr} from './expression_converter';
+import {ViewProperties} from './constants';
 
 export class CompileEventListener {
   private _method: CompileMethod;
@@ -61,23 +60,14 @@ export class CompileEventListener {
     }
     this._method.resetDebugInfo(this.compileElement.nodeIndex, hostEvent);
     var context = directiveInstance || this.compileElement.view.componentContext;
-    var actionStmts = convertCdStatementToIr(
-        this.compileElement.view, context, hostEvent.handler, this.compileElement.nodeIndex);
-    var lastIndex = actionStmts.length - 1;
-    if (lastIndex >= 0) {
-      var lastStatement = actionStmts[lastIndex];
-      var returnExpr = convertStmtIntoExpression(lastStatement);
-      var preventDefaultVar = o.variable(`pd_${this._actionResultExprs.length}`);
-      this._actionResultExprs.push(preventDefaultVar);
-      if (isPresent(returnExpr)) {
-        // Note: We need to cast the result of the method call to dynamic,
-        // as it might be a void method!
-        actionStmts[lastIndex] =
-            preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
-                .toDeclStmt(null, [o.StmtModifier.Final]);
-      }
+    const view = this.compileElement.view;
+    const evalResult = convertActionBinding(
+        view, directive ? null : view, context, hostEvent.handler,
+        `${this.compileElement.nodeIndex}_${this._actionResultExprs.length}`);
+    if (evalResult.preventDefault) {
+      this._actionResultExprs.push(evalResult.preventDefault);
     }
-    this._method.addStmts(actionStmts);
+    this._method.addStmts(evalResult.stmts);
   }
 
   finishMethod() {
@@ -91,7 +81,7 @@ export class CompileEventListener {
             .concat(this._method.finish())
             .concat([new o.ReturnStatement(resultExpr)]);
     // private is fine here as no child view will reference the event handler...
-    this.compileElement.view.eventHandlerMethods.push(new o.ClassMethod(
+    this.compileElement.view.methods.push(new o.ClassMethod(
         this._methodName, [this._eventParam], stmts, o.BOOL_TYPE, [o.StmtModifier.Private]));
   }
 
@@ -143,7 +133,6 @@ export function collectEventListeners(
   const eventListeners: CompileEventListener[] = [];
 
   hostEvents.forEach((hostEvent) => {
-    compileElement.view.bindings.push(new CompileBinding(compileElement, hostEvent));
     var listener = CompileEventListener.getOrCreate(
         compileElement, hostEvent.target, hostEvent.name, hostEvent.phase, eventListeners);
     listener.addAction(hostEvent, null, null);
@@ -153,7 +142,6 @@ export function collectEventListeners(
     var directiveInstance =
         compileElement.instances.get(identifierToken(directiveAst.directive.type).reference);
     directiveAst.hostEvents.forEach((hostEvent) => {
-      compileElement.view.bindings.push(new CompileBinding(compileElement, hostEvent));
       var listener = CompileEventListener.getOrCreate(
           compileElement, hostEvent.target, hostEvent.name, hostEvent.phase, eventListeners);
       listener.addAction(hostEvent, directiveAst.directive, directiveInstance);

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

@@ -20,27 +20,6 @@ import {DetectChangesVars} from './constants';
 var STATE_IS_NEVER_CHECKED = o.THIS_EXPR.prop('numberOfChecks').identical(new o.LiteralExpr(0));
 var NOT_THROW_ON_CHANGES = o.not(DetectChangesVars.throwOnChange);
 
-export function bindDirectiveDetectChangesLifecycleCallbacks(
-    directiveAst: DirectiveAst, directiveInstance: o.Expression, compileElement: CompileElement) {
-  var view = compileElement.view;
-  var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
-  var lifecycleHooks = directiveAst.directive.type.lifecycleHooks;
-  if (lifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1 && directiveAst.inputs.length > 0) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(
-        DetectChangesVars.changes.notIdentical(o.NULL_EXPR),
-        [directiveInstance.callMethod('ngOnChanges', [DetectChangesVars.changes]).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.OnInit) !== -1) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(
-        STATE_IS_NEVER_CHECKED.and(NOT_THROW_ON_CHANGES),
-        [directiveInstance.callMethod('ngOnInit', []).toStmt()]));
-  }
-  if (lifecycleHooks.indexOf(LifecycleHooks.DoCheck) !== -1) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(
-        NOT_THROW_ON_CHANGES, [directiveInstance.callMethod('ngDoCheck', []).toStmt()]));
-  }
-}
-
 export function bindDirectiveAfterContentLifecycleCallbacks(
     directiveMeta: CompileDirectiveMetadata, directiveInstance: o.Expression,
     compileElement: CompileElement) {

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

@@ -8,85 +8,40 @@
 
 import {SecurityContext} from '@angular/core';
 
+import {createCheckBindingField, createCheckBindingStmt} from '../compiler_util/binding_util';
+import {ConvertPropertyBindingResult, convertPropertyBinding} from '../compiler_util/expression_converter';
+import {createEnumExpression} from '../compiler_util/identifier_util';
+import {writeToRenderer} from '../compiler_util/render_util';
 import * as cdAst from '../expression_parser/ast';
 import {isPresent} from '../facade/lang';
 import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {EMPTY_STATE as EMPTY_ANIMATION_STATE, LifecycleHooks, isDefaultChangeDetectionStrategy} from '../private_import_core';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {BoundElementPropertyAst, BoundTextAst, DirectiveAst, PropertyBindingType} from '../template_parser/template_ast';
 import {camelCaseToDashCase} from '../util';
 
-import {CompileBinding} from './compile_binding';
 import {CompileElement, CompileNode} from './compile_element';
 import {CompileMethod} from './compile_method';
 import {CompileView} from './compile_view';
 import {DetectChangesVars, ViewProperties} from './constants';
 import {CompileEventListener} from './event_binder';
-import {convertCdExpressionToIr, temporaryDeclaration} from './expression_converter';
-
-function createBindFieldExpr(exprIndex: number): o.ReadPropExpr {
-  return o.THIS_EXPR.prop(`_expr_${exprIndex}`);
-}
-
-function createCurrValueExpr(exprIndex: number): o.ReadVarExpr {
-  return o.variable(`currVal_${exprIndex}`);  // fix syntax highlighting: `
-}
-
-function bind(
-    view: CompileView, currValExpr: o.ReadVarExpr, fieldExpr: o.ReadPropExpr,
-    parsedExpression: cdAst.AST, context: o.Expression, actions: o.Statement[],
-    method: CompileMethod, bindingIndex: number) {
-  var checkExpression = convertCdExpressionToIr(
-      view, context, parsedExpression, DetectChangesVars.valUnwrapper, bindingIndex);
-  if (!checkExpression.expression) {
-    // e.g. an empty expression was given
-    return;
-  }
-
-  if (checkExpression.temporaryCount) {
-    for (let i = 0; i < checkExpression.temporaryCount; i++) {
-      method.addStmt(temporaryDeclaration(bindingIndex, i));
-    }
-  }
-
-  // private is fine here as no child view will reference the cached value...
-  view.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
-  view.createMethod.addStmt(o.THIS_EXPR.prop(fieldExpr.name)
-                                .set(o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED)))
-                                .toStmt());
-
-  if (checkExpression.needsValueUnwrapper) {
-    var initValueUnwrapperStmt = DetectChangesVars.valUnwrapper.callMethod('reset', []).toStmt();
-    method.addStmt(initValueUnwrapperStmt);
-  }
-  method.addStmt(
-      currValExpr.set(checkExpression.expression).toDeclStmt(null, [o.StmtModifier.Final]));
-
-  var condition: o.Expression = o.importExpr(resolveIdentifier(Identifiers.checkBinding)).callFn([
-    DetectChangesVars.throwOnChange, fieldExpr, currValExpr
-  ]);
-  if (checkExpression.needsValueUnwrapper) {
-    condition = DetectChangesVars.valUnwrapper.prop('hasWrappedValue').or(condition);
-  }
-  method.addStmt(new o.IfStmt(
-      condition,
-      actions.concat([<o.Statement>o.THIS_EXPR.prop(fieldExpr.name).set(currValExpr).toStmt()])));
-}
 
 export function bindRenderText(
-    boundText: BoundTextAst, compileNode: CompileNode, view: CompileView) {
-  var bindingIndex = view.bindings.length;
-  view.bindings.push(new CompileBinding(compileNode, boundText));
-  var currValExpr = createCurrValueExpr(bindingIndex);
-  var valueField = createBindFieldExpr(bindingIndex);
-  view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileNode.nodeIndex, boundText);
+    boundText: BoundTextAst, compileNode: CompileNode, view: CompileView): void {
+  const valueField = createCheckBindingField(view);
+  const evalResult = convertPropertyBinding(
+      view, view, view.componentContext, boundText.value, valueField.bindingId);
+  if (!evalResult) {
+    return null;
+  }
 
-  bind(
-      view, currValExpr, valueField, boundText.value, view.componentContext,
+  view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileNode.nodeIndex, boundText);
+  view.detectChangesRenderPropertiesMethod.addStmts(createCheckBindingStmt(
+      evalResult, valueField.expression, DetectChangesVars.throwOnChange,
       [o.THIS_EXPR.prop('renderer')
-           .callMethod('setText', [compileNode.renderNode, currValExpr])
-           .toStmt()],
-      view.detectChangesRenderPropertiesMethod, bindingIndex);
+           .callMethod('setText', [compileNode.renderNode, evalResult.currValExpr])
+           .toStmt()]));
 }
 
 function bindAndWriteToRenderer(
@@ -95,52 +50,20 @@ function bindAndWriteToRenderer(
   var view = compileElement.view;
   var renderNode = compileElement.renderNode;
   boundProps.forEach((boundProp) => {
-    var bindingIndex = view.bindings.length;
-    view.bindings.push(new CompileBinding(compileElement, boundProp));
+    const bindingField = createCheckBindingField(view);
     view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileElement.nodeIndex, boundProp);
-    var fieldExpr = createBindFieldExpr(bindingIndex);
-    var currValExpr = createCurrValueExpr(bindingIndex);
-    var oldRenderValue: o.Expression = sanitizedValue(boundProp, fieldExpr);
-    var renderValue: o.Expression = sanitizedValue(boundProp, currValExpr);
+    const evalResult = convertPropertyBinding(
+        view, isHostProp ? null : view, context, boundProp.value, bindingField.bindingId);
     var updateStmts: o.Statement[] = [];
     var compileMethod = view.detectChangesRenderPropertiesMethod;
     switch (boundProp.type) {
       case PropertyBindingType.Property:
-        if (view.genConfig.logBindingUpdate) {
-          updateStmts.push(logBindingUpdateStmt(renderNode, boundProp.name, renderValue));
-        }
-        updateStmts.push(
-            o.THIS_EXPR.prop('renderer')
-                .callMethod(
-                    'setElementProperty', [renderNode, o.literal(boundProp.name), renderValue])
-                .toStmt());
-        break;
       case PropertyBindingType.Attribute:
-        renderValue =
-            renderValue.isBlank().conditional(o.NULL_EXPR, renderValue.callMethod('toString', []));
-        updateStmts.push(
-            o.THIS_EXPR.prop('renderer')
-                .callMethod(
-                    'setElementAttribute', [renderNode, o.literal(boundProp.name), renderValue])
-                .toStmt());
-        break;
       case PropertyBindingType.Class:
-        updateStmts.push(
-            o.THIS_EXPR.prop('renderer')
-                .callMethod('setElementClass', [renderNode, o.literal(boundProp.name), renderValue])
-                .toStmt());
-        break;
       case PropertyBindingType.Style:
-        var strValue: o.Expression = renderValue.callMethod('toString', []);
-        if (isPresent(boundProp.unit)) {
-          strValue = strValue.plus(o.literal(boundProp.unit));
-        }
-
-        renderValue = renderValue.isBlank().conditional(o.NULL_EXPR, strValue);
-        updateStmts.push(
-            o.THIS_EXPR.prop('renderer')
-                .callMethod('setElementStyle', [renderNode, o.literal(boundProp.name), renderValue])
-                .toStmt());
+        updateStmts.push(...writeToRenderer(
+            o.THIS_EXPR, boundProp, renderNode, evalResult.currValExpr,
+            view.genConfig.logBindingUpdate));
         break;
       case PropertyBindingType.Animation:
         compileMethod = view.animationBindingsMethod;
@@ -159,20 +82,22 @@ function bindAndWriteToRenderer(
         const unitializedValue = o.importExpr(resolveIdentifier(Identifiers.UNINITIALIZED));
         const animationTransitionVar = o.variable('animationTransition_' + animationName);
 
-        updateStmts.push(
-            animationTransitionVar
-                .set(animationFnExpr.callFn([
-                  o.THIS_EXPR, renderNode, oldRenderValue.equals(unitializedValue)
-                                               .conditional(emptyStateValue, oldRenderValue),
-                  renderValue.equals(unitializedValue).conditional(emptyStateValue, renderValue)
-                ]))
-                .toDeclStmt());
-
-        detachStmts.push(animationTransitionVar
-                             .set(animationFnExpr.callFn(
-                                 [o.THIS_EXPR, renderNode, oldRenderValue, emptyStateValue]))
+        updateStmts.push(animationTransitionVar
+                             .set(animationFnExpr.callFn([
+                               o.THIS_EXPR, renderNode,
+                               bindingField.expression.equals(unitializedValue)
+                                   .conditional(emptyStateValue, bindingField.expression),
+                               evalResult.currValExpr.equals(unitializedValue)
+                                   .conditional(emptyStateValue, evalResult.currValExpr)
+                             ]))
                              .toDeclStmt());
 
+        detachStmts.push(
+            animationTransitionVar
+                .set(animationFnExpr.callFn(
+                    [o.THIS_EXPR, renderNode, bindingField.expression, emptyStateValue]))
+                .toDeclStmt());
+
         eventListeners.forEach(listener => {
           if (listener.isAnimation && listener.eventName === animationName) {
             let animationStmt = listener.listenToAnimation(animationTransitionVar);
@@ -185,43 +110,11 @@ function bindAndWriteToRenderer(
 
         break;
     }
-
-    bind(
-        view, currValExpr, fieldExpr, boundProp.value, context, updateStmts, compileMethod,
-        view.bindings.length);
+    compileMethod.addStmts(createCheckBindingStmt(
+        evalResult, bindingField.expression, DetectChangesVars.throwOnChange, updateStmts));
   });
 }
 
-function sanitizedValue(
-    boundProp: BoundElementPropertyAst, renderValue: o.Expression): o.Expression {
-  let enumValue: string;
-  switch (boundProp.securityContext) {
-    case SecurityContext.NONE:
-      return renderValue;  // No sanitization needed.
-    case SecurityContext.HTML:
-      enumValue = 'HTML';
-      break;
-    case SecurityContext.STYLE:
-      enumValue = 'STYLE';
-      break;
-    case SecurityContext.SCRIPT:
-      enumValue = 'SCRIPT';
-      break;
-    case SecurityContext.URL:
-      enumValue = 'URL';
-      break;
-    case SecurityContext.RESOURCE_URL:
-      enumValue = 'RESOURCE_URL';
-      break;
-    default:
-      throw new Error(`internal error, unexpected SecurityContext ${boundProp.securityContext}.`);
-  }
-  let ctx = ViewProperties.viewUtils.prop('sanitizer');
-  let args =
-      [o.importExpr(resolveIdentifier(Identifiers.SecurityContext)).prop(enumValue), renderValue];
-  return ctx.callMethod('sanitize', args);
-}
-
 export function bindRenderInputs(
     boundProps: BoundElementPropertyAst[], compileElement: CompileElement,
     eventListeners: CompileEventListener[]): void {
@@ -230,89 +123,77 @@ export function bindRenderInputs(
 }
 
 export function bindDirectiveHostProps(
-    directiveAst: DirectiveAst, directiveInstance: o.Expression, compileElement: CompileElement,
-    eventListeners: CompileEventListener[]): void {
+    directiveAst: DirectiveAst, directiveWrapperInstance: o.Expression,
+    compileElement: CompileElement, eventListeners: CompileEventListener[], elementName: string,
+    schemaRegistry: ElementSchemaRegistry): void {
+  // host properties are change detected by the DirectiveWrappers,
+  // except for the animation properties as they need close integration with animation events
+  // and DirectiveWrappers don't support
+  // event listeners right now.
   bindAndWriteToRenderer(
-      directiveAst.hostProperties, directiveInstance, compileElement, true, eventListeners);
+      directiveAst.hostProperties.filter(boundProp => boundProp.isAnimation),
+      directiveWrapperInstance.prop('context'), compileElement, true, eventListeners);
+
+
+  const methodArgs: o.Expression[] =
+      [o.THIS_EXPR, compileElement.renderNode, DetectChangesVars.throwOnChange];
+  // We need to provide the SecurityContext for properties that could need sanitization.
+  directiveAst.hostProperties.filter(boundProp => boundProp.needsRuntimeSecurityContext)
+      .forEach((boundProp) => {
+        let ctx: SecurityContext;
+        switch (boundProp.type) {
+          case PropertyBindingType.Property:
+            ctx = schemaRegistry.securityContext(elementName, boundProp.name, false);
+            break;
+          case PropertyBindingType.Attribute:
+            ctx = schemaRegistry.securityContext(elementName, boundProp.name, true);
+            break;
+          default:
+            throw new Error(
+                `Illegal state: Only property / attribute bindings can have an unknown security context! Binding ${boundProp.name}`);
+        }
+        methodArgs.push(createEnumExpression(Identifiers.SecurityContext, ctx));
+      });
+  compileElement.view.detectChangesRenderPropertiesMethod.addStmt(
+      directiveWrapperInstance.callMethod('detectChangesInHostProps', methodArgs).toStmt());
 }
 
 export function bindDirectiveInputs(
-    directiveAst: DirectiveAst, directiveInstance: o.Expression, compileElement: CompileElement) {
-  if (directiveAst.inputs.length === 0) {
-    return;
-  }
+    directiveAst: DirectiveAst, directiveWrapperInstance: o.Expression, dirIndex: number,
+    compileElement: CompileElement) {
   var view = compileElement.view;
   var detectChangesInInputsMethod = view.detectChangesInInputsMethod;
   detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, compileElement.sourceAst);
 
-  var lifecycleHooks = directiveAst.directive.type.lifecycleHooks;
-  var calcChangesMap = lifecycleHooks.indexOf(LifecycleHooks.OnChanges) !== -1;
+  directiveAst.inputs.forEach((input, inputIdx) => {
+    // Note: We can't use `fields.length` here, as we are not adding a field!
+    const bindingId = `${compileElement.nodeIndex}_${dirIndex}_${inputIdx}`;
+    detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, input);
+    const evalResult =
+        convertPropertyBinding(view, view, view.componentContext, input.value, bindingId);
+    if (!evalResult) {
+      return;
+    }
+    detectChangesInInputsMethod.addStmts(evalResult.stmts);
+    detectChangesInInputsMethod.addStmt(
+        directiveWrapperInstance
+            .callMethod(
+                `check_${input.directiveName}`,
+                [
+                  evalResult.currValExpr, DetectChangesVars.throwOnChange,
+                  evalResult.forceUpdate || o.literal(false)
+                ])
+            .toStmt());
+  });
   var isOnPushComp = directiveAst.directive.isComponent &&
       !isDefaultChangeDetectionStrategy(directiveAst.directive.changeDetection);
-  if (calcChangesMap) {
-    detectChangesInInputsMethod.addStmt(DetectChangesVars.changes.set(o.NULL_EXPR).toStmt());
-  }
-  if (isOnPushComp) {
-    detectChangesInInputsMethod.addStmt(DetectChangesVars.changed.set(o.literal(false)).toStmt());
-  }
-  directiveAst.inputs.forEach((input) => {
-    var bindingIndex = view.bindings.length;
-    view.bindings.push(new CompileBinding(compileElement, input));
-    detectChangesInInputsMethod.resetDebugInfo(compileElement.nodeIndex, input);
-    var fieldExpr = createBindFieldExpr(bindingIndex);
-    var currValExpr = createCurrValueExpr(bindingIndex);
-    var statements: o.Statement[] =
-        [directiveInstance.prop(input.directiveName).set(currValExpr).toStmt()];
-    if (calcChangesMap) {
-      statements.push(new o.IfStmt(
-          DetectChangesVars.changes.identical(o.NULL_EXPR),
-          [DetectChangesVars.changes
-               .set(o.literalMap(
-                   [], new o.MapType(o.importType(resolveIdentifier(Identifiers.SimpleChange)))))
-               .toStmt()]));
-      statements.push(DetectChangesVars.changes.key(o.literal(input.directiveName))
-                          .set(o.importExpr(resolveIdentifier(Identifiers.SimpleChange))
-                                   .instantiate([fieldExpr, currValExpr]))
-                          .toStmt());
-    }
-    if (isOnPushComp) {
-      statements.push(DetectChangesVars.changed.set(o.literal(true)).toStmt());
-    }
-    if (view.genConfig.logBindingUpdate) {
-      statements.push(
-          logBindingUpdateStmt(compileElement.renderNode, input.directiveName, currValExpr));
-    }
-    bind(
-        view, currValExpr, fieldExpr, input.value, view.componentContext, statements,
-        detectChangesInInputsMethod, bindingIndex);
-  });
-  if (isOnPushComp) {
-    detectChangesInInputsMethod.addStmt(new o.IfStmt(DetectChangesVars.changed, [
-      compileElement.appElement.prop('componentView').callMethod('markAsCheckOnce', []).toStmt()
-    ]));
-  }
-}
-
-function logBindingUpdateStmt(
-    renderNode: o.Expression, propName: string, value: o.Expression): o.Statement {
-  const tryStmt =
-      o.THIS_EXPR.prop('renderer')
-          .callMethod(
-              'setBindingDebugInfo',
-              [
-                renderNode, o.literal(`ng-reflect-${camelCaseToDashCase(propName)}`),
-                value.isBlank().conditional(o.NULL_EXPR, value.callMethod('toString', []))
-              ])
-          .toStmt();
-
-  const catchStmt = o.THIS_EXPR.prop('renderer')
-                        .callMethod(
-                            'setBindingDebugInfo',
-                            [
-                              renderNode, o.literal(`ng-reflect-${camelCaseToDashCase(propName)}`),
-                              o.literal('[ERROR] Exception while trying to serialize the value')
-                            ])
-                        .toStmt();
-
-  return new o.TryCatchStmt([tryStmt], [catchStmt]);
+  let directiveDetectChangesExpr = directiveWrapperInstance.callMethod(
+      'detectChangesInInputProps',
+      [o.THIS_EXPR, compileElement.renderNode, DetectChangesVars.throwOnChange]);
+  const directiveDetectChangesStmt = isOnPushComp ?
+      new o.IfStmt(directiveDetectChangesExpr, [compileElement.appElement.prop('componentView')
+                                                    .callMethod('markAsCheckOnce', [])
+                                                    .toStmt()]) :
+      directiveDetectChangesExpr.toStmt();
+  detectChangesInInputsMethod.addStmt(directiveDetectChangesStmt);
 }

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

@@ -7,11 +7,11 @@
  */
 
 
-import {CompileDirectiveMetadata, CompileTokenMetadata} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileTokenMetadata} from '../compile_metadata';
+import {createDiTokenExpression} from '../compiler_util/identifier_util';
 import {isPresent} from '../facade/lang';
 import {Identifiers, resolveIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
-import {createDiTokenExpression} from '../util';
 
 import {CompileView} from './compile_view';
 
@@ -30,15 +30,28 @@ export function getPropertyInView(
       throw new Error(
           `Internal error: Could not calculate a property in a parent view: ${property}`);
     }
-    if (property instanceof o.ReadPropExpr) {
-      let readPropExpr: o.ReadPropExpr = property;
+    return property.visitExpression(new _ReplaceViewTransformer(viewProp, definedView), null);
+  }
+}
+
+class _ReplaceViewTransformer extends o.ExpressionTransformer {
+  constructor(private _viewExpr: o.Expression, private _view: CompileView) { super(); }
+  private _isThis(expr: o.Expression): boolean {
+    return expr instanceof o.ReadVarExpr && expr.builtin === o.BuiltinVar.This;
+  }
+
+  visitReadVarExpr(ast: o.ReadVarExpr, context: any): any {
+    return this._isThis(ast) ? this._viewExpr : ast;
+  }
+  visitReadPropExpr(ast: o.ReadPropExpr, context: any): any {
+    if (this._isThis(ast.receiver)) {
       // Note: Don't cast for members of the AppView base class...
-      if (definedView.fields.some((field) => field.name == readPropExpr.name) ||
-          definedView.getters.some((field) => field.name == readPropExpr.name)) {
-        viewProp = viewProp.cast(definedView.classType);
+      if (this._view.fields.some((field) => field.name == ast.name) ||
+          this._view.getters.some((field) => field.name == ast.name)) {
+        return this._viewExpr.cast(this._view.classType).prop(ast.name);
       }
     }
-    return o.replaceVarInExpression(o.THIS_EXPR.name, viewProp, property);
+    return super.visitReadPropExpr(ast, context);
   }
 }
 
@@ -78,16 +91,3 @@ export function createFlatArray(expressions: o.Expression[]): o.Expression {
   }
   return result;
 }
-
-export function createPureProxy(
-    fn: o.Expression, argCount: number, pureProxyProp: o.ReadPropExpr, view: CompileView) {
-  view.fields.push(new o.ClassField(pureProxyProp.name, null));
-  var pureProxyId =
-      argCount < Identifiers.pureProxies.length ? Identifiers.pureProxies[argCount] : null;
-  if (!pureProxyId) {
-    throw new Error(`Unsupported number of argument for pure functions: ${argCount}`);
-  }
-  view.createMethod.addStmt(o.THIS_EXPR.prop(pureProxyProp.name)
-                                .set(o.importExpr(resolveIdentifier(pureProxyId)).callFn([fn]))
-                                .toStmt());
-}

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

@@ -6,16 +6,18 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from '../template_parser/template_ast';
 
 import {CompileElement} from './compile_element';
 import {CompileView} from './compile_view';
 import {CompileEventListener, bindDirectiveOutputs, bindRenderOutputs, collectEventListeners} from './event_binder';
-import {bindDirectiveAfterContentLifecycleCallbacks, bindDirectiveAfterViewLifecycleCallbacks, bindDirectiveDetectChangesLifecycleCallbacks, bindInjectableDestroyLifecycleCallbacks, bindPipeDestroyLifecycleCallbacks} from './lifecycle_binder';
+import {bindDirectiveAfterContentLifecycleCallbacks, bindDirectiveAfterViewLifecycleCallbacks, bindInjectableDestroyLifecycleCallbacks, bindPipeDestroyLifecycleCallbacks} from './lifecycle_binder';
 import {bindDirectiveHostProps, bindDirectiveInputs, bindRenderInputs, bindRenderText} from './property_binder';
 
-export function bindView(view: CompileView, parsedTemplate: TemplateAst[]): void {
-  var visitor = new ViewBinderVisitor(view);
+export function bindView(
+    view: CompileView, parsedTemplate: TemplateAst[], schemaRegistry: ElementSchemaRegistry): void {
+  var visitor = new ViewBinderVisitor(view, schemaRegistry);
   templateVisitAll(visitor, parsedTemplate);
   view.pipes.forEach(
       (pipe) => { bindPipeDestroyLifecycleCallbacks(pipe.meta, pipe.instance, pipe.view); });
@@ -24,7 +26,7 @@ export function bindView(view: CompileView, parsedTemplate: TemplateAst[]): void
 class ViewBinderVisitor implements TemplateAstVisitor {
   private _nodeIndex: number = 0;
 
-  constructor(public view: CompileView) {}
+  constructor(public view: CompileView, private _schemaRegistry: ElementSchemaRegistry) {}
 
   visitBoundText(ast: BoundTextAst, parent: CompileElement): any {
     var node = this.view.nodes[this._nodeIndex++];
@@ -46,12 +48,15 @@ class ViewBinderVisitor implements TemplateAstVisitor {
     });
     bindRenderInputs(ast.inputs, compileElement, eventListeners);
     bindRenderOutputs(eventListeners);
-    ast.directives.forEach((directiveAst) => {
+    ast.directives.forEach((directiveAst, dirIndex) => {
       var directiveInstance = compileElement.instances.get(directiveAst.directive.type.reference);
-      bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
-      bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
+      var directiveWrapperInstance =
+          compileElement.directiveWrapperInstance.get(directiveAst.directive.type.reference);
+      bindDirectiveInputs(directiveAst, directiveWrapperInstance, dirIndex, compileElement);
 
-      bindDirectiveHostProps(directiveAst, directiveInstance, compileElement, eventListeners);
+      bindDirectiveHostProps(
+          directiveAst, directiveWrapperInstance, compileElement, eventListeners, ast.name,
+          this._schemaRegistry);
       bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
     });
     templateVisitAll(this, ast.children, compileElement);
@@ -74,10 +79,12 @@ class ViewBinderVisitor implements TemplateAstVisitor {
   visitEmbeddedTemplate(ast: EmbeddedTemplateAst, parent: CompileElement): any {
     var compileElement = <CompileElement>this.view.nodes[this._nodeIndex++];
     var eventListeners = collectEventListeners(ast.outputs, ast.directives, compileElement);
-    ast.directives.forEach((directiveAst) => {
+    ast.directives.forEach((directiveAst, dirIndex) => {
       var directiveInstance = compileElement.instances.get(directiveAst.directive.type.reference);
-      bindDirectiveInputs(directiveAst, directiveInstance, compileElement);
-      bindDirectiveDetectChangesLifecycleCallbacks(directiveAst, directiveInstance, compileElement);
+      var directiveWrapperInstance =
+          compileElement.directiveWrapperInstance.get(directiveAst.directive.type.reference);
+      bindDirectiveInputs(directiveAst, directiveWrapperInstance, dirIndex, compileElement);
+
       bindDirectiveOutputs(directiveAst, directiveInstance, eventListeners);
       bindDirectiveAfterContentLifecycleCallbacks(
           directiveAst.directive, directiveInstance, compileElement);
@@ -88,7 +95,7 @@ class ViewBinderVisitor implements TemplateAstVisitor {
       var providerInstance = compileElement.instances.get(providerAst.token.reference);
       bindInjectableDestroyLifecycleCallbacks(providerAst, providerInstance, compileElement);
     });
-    bindView(compileElement.embeddedView, ast.children);
+    bindView(compileElement.embeddedView, ast.children, this._schemaRegistry);
     return null;
   }
 

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

@@ -9,17 +9,19 @@
 import {ViewEncapsulation} from '@angular/core';
 
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileTokenMetadata} from '../compile_metadata';
-import {ListWrapper} from '../facade/collection';
+import {createSharedBindingVariablesIfNeeded} from '../compiler_util/expression_converter';
+import {createDiTokenExpression, createInlineArray} from '../compiler_util/identifier_util';
 import {isPresent} from '../facade/lang';
 import {Identifiers, identifierToken, resolveIdentifier} from '../identifiers';
+import {createClassStmt} from '../output/class_builder';
 import * as o from '../output/output_ast';
 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';
-import {createDiTokenExpression} from '../util';
 
 import {CompileElement, CompileNode} from './compile_element';
 import {CompileView} from './compile_view';
 import {ChangeDetectorStatusEnum, DetectChangesVars, InjectMethodVars, ViewConstructorVars, ViewEncapsulationEnum, ViewProperties, ViewTypeEnum} from './constants';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewFactoryDependency} from './deps';
 import {createFlatArray, getViewFactoryName} from './util';
 
 const IMPLICIT_TEMPLATE_VAR = '\$implicit';
@@ -30,20 +32,11 @@ const NG_CONTAINER_TAG = 'ng-container';
 var parentRenderNodeVar = o.variable('parentRenderNode');
 var rootSelectorVar = o.variable('rootSelector');
 
-export class ViewFactoryDependency {
-  constructor(
-      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
-}
-
-export class ComponentFactoryDependency {
-  constructor(
-      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
-}
-
-
 export function buildView(
     view: CompileView, template: TemplateAst[],
-    targetDependencies: Array<ViewFactoryDependency|ComponentFactoryDependency>): number {
+    targetDependencies:
+        Array<ViewFactoryDependency|ComponentFactoryDependency|DirectiveWrapperDependency>):
+    number {
   var builderVisitor = new ViewBuilderVisitor(view, targetDependencies);
   templateVisitAll(
       builderVisitor, template,
@@ -66,7 +59,8 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
 
   constructor(
       public view: CompileView,
-      public targetDependencies: Array<ViewFactoryDependency|ComponentFactoryDependency>) {}
+      public targetDependencies:
+          Array<ViewFactoryDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {}
 
   private _isRootNode(parent: CompileElement): boolean { return parent.view !== this.view; }
 
@@ -164,19 +158,29 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
 
   visitElement(ast: ElementAst, parent: CompileElement): any {
     var nodeIndex = this.view.nodes.length;
-    var createRenderNodeExpr: o.InvokeMethodExpr;
+    var createRenderNodeExpr: o.Expression;
     var debugContextExpr = this.view.createMethod.resetDebugInfoExpr(nodeIndex, ast);
-    if (nodeIndex === 0 && this.view.viewType === ViewType.HOST) {
-      createRenderNodeExpr = o.THIS_EXPR.callMethod(
-          'selectOrCreateHostElement', [o.literal(ast.name), rootSelectorVar, debugContextExpr]);
+    var directives = ast.directives.map(directiveAst => directiveAst.directive);
+    var component = directives.find(directive => directive.isComponent);
+    if (ast.name === NG_CONTAINER_TAG) {
+      createRenderNodeExpr = ViewProperties.renderer.callMethod(
+          'createTemplateAnchor', [this._getParentRenderNode(parent), debugContextExpr]);
     } else {
-      if (ast.name === NG_CONTAINER_TAG) {
-        createRenderNodeExpr = ViewProperties.renderer.callMethod(
-            'createTemplateAnchor', [this._getParentRenderNode(parent), debugContextExpr]);
+      const htmlAttrs = _readHtmlAttrs(ast.attrs);
+      const attrNameAndValues = createInlineArray(
+          _mergeHtmlAndDirectiveAttrs(htmlAttrs, directives).map(v => o.literal(v)));
+      if (nodeIndex === 0 && this.view.viewType === ViewType.HOST) {
+        createRenderNodeExpr =
+            o.importExpr(resolveIdentifier(Identifiers.selectOrCreateRenderHostElement)).callFn([
+              ViewProperties.renderer, o.literal(ast.name), attrNameAndValues, rootSelectorVar,
+              debugContextExpr
+            ]);
       } else {
-        createRenderNodeExpr = ViewProperties.renderer.callMethod(
-            'createElement',
-            [this._getParentRenderNode(parent), o.literal(ast.name), debugContextExpr]);
+        createRenderNodeExpr =
+            o.importExpr(resolveIdentifier(Identifiers.createRenderElement)).callFn([
+              ViewProperties.renderer, this._getParentRenderNode(parent), o.literal(ast.name),
+              attrNameAndValues, debugContextExpr
+            ]);
       }
     }
     var fieldName = `_el_${nodeIndex}`;
@@ -186,25 +190,9 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
 
     var renderNode = o.THIS_EXPR.prop(fieldName);
 
-    var directives = ast.directives.map(directiveAst => directiveAst.directive);
-    var component = directives.find(directive => directive.isComponent);
-    var htmlAttrs = _readHtmlAttrs(ast.attrs);
-    var attrNameAndValues = _mergeHtmlAndDirectiveAttrs(htmlAttrs, directives);
-    for (var i = 0; i < attrNameAndValues.length; i++) {
-      const attrName = attrNameAndValues[i][0];
-      if (ast.name !== NG_CONTAINER_TAG) {
-        // <ng-container> are not rendered in the DOM
-        const attrValue = attrNameAndValues[i][1];
-        this.view.createMethod.addStmt(
-            ViewProperties.renderer
-                .callMethod(
-                    'setElementAttribute', [renderNode, o.literal(attrName), o.literal(attrValue)])
-                .toStmt());
-      }
-    }
     var compileElement = new CompileElement(
         parent, this.view, nodeIndex, renderNode, ast, component, directives, ast.providers,
-        ast.hasViewContainer, false, ast.references);
+        ast.hasViewContainer, false, ast.references, this.targetDependencies);
     this.view.nodes.push(compileElement);
     var compViewExpr: o.ReadVarExpr = null;
     if (isPresent(component)) {
@@ -212,13 +200,6 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
           new CompileIdentifierMetadata({name: getViewFactoryName(component, 0)});
       this.targetDependencies.push(
           new ViewFactoryDependency(component.type, nestedComponentIdentifier));
-      let entryComponentIdentifiers =
-          component.entryComponents.map((entryComponent: CompileIdentifierMetadata) => {
-            var id = new CompileIdentifierMetadata({name: entryComponent.name});
-            this.targetDependencies.push(new ComponentFactoryDependency(entryComponent, id));
-            return id;
-          });
-      compileElement.createComponentFactoryResolver(entryComponentIdentifiers);
 
       compViewExpr = o.variable(`compView_${nodeIndex}`);  // fix highlighting: `
       compileElement.setComponentView(compViewExpr);
@@ -273,7 +254,7 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
     var directives = ast.directives.map(directiveAst => directiveAst.directive);
     var compileElement = new CompileElement(
         parent, this.view, nodeIndex, renderNode, ast, null, directives, ast.providers,
-        ast.hasViewContainer, true, ast.references);
+        ast.hasViewContainer, true, ast.references, this.targetDependencies);
     this.view.nodes.push(compileElement);
 
     this.nestedViewCount++;
@@ -343,18 +324,22 @@ function _isNgContainer(node: CompileNode, view: CompileView): boolean {
 
 
 function _mergeHtmlAndDirectiveAttrs(
-    declaredHtmlAttrs: {[key: string]: string},
-    directives: CompileDirectiveMetadata[]): string[][] {
-  var result: {[key: string]: string} = {};
-  Object.keys(declaredHtmlAttrs).forEach(key => { result[key] = declaredHtmlAttrs[key]; });
+    declaredHtmlAttrs: {[key: string]: string}, directives: CompileDirectiveMetadata[]): string[] {
+  const mapResult: {[key: string]: string} = {};
+  Object.keys(declaredHtmlAttrs).forEach(key => { mapResult[key] = declaredHtmlAttrs[key]; });
   directives.forEach(directiveMeta => {
     Object.keys(directiveMeta.hostAttributes).forEach(name => {
       const value = directiveMeta.hostAttributes[name];
-      var prevValue = result[name];
-      result[name] = isPresent(prevValue) ? mergeAttributeValue(name, prevValue, value) : value;
+      const prevValue = mapResult[name];
+      mapResult[name] = isPresent(prevValue) ? mergeAttributeValue(name, prevValue, value) : value;
     });
   });
-  return mapToKeyValueArray(result);
+  const arrResult: string[] = [];
+  // Note: We need to sort to get a defined output order
+  // for tests and for caching generated artifacts...
+  Object.keys(mapResult).sort().forEach(
+      (attrName) => { arrResult.push(attrName, mapResult[attrName]); });
+  return arrResult;
 }
 
 function _readHtmlAttrs(attrs: AttrAst[]): {[key: string]: string} {
@@ -371,15 +356,6 @@ function mergeAttributeValue(attrName: string, attrValue1: string, attrValue2: s
   }
 }
 
-function mapToKeyValueArray(data: {[key: string]: string}): string[][] {
-  var entryArray: string[][] = [];
-  Object.keys(data).forEach(name => { entryArray.push([name, data[name]]); });
-  // We need to sort to get a defined output order
-  // for tests and for caching generated artifacts...
-  ListWrapper.sort(entryArray);
-  return entryArray;
-}
-
 function createViewTopLevelStmts(view: CompileView, targetStatements: o.Statement[]) {
   var nodeDebugInfosVar: o.Expression = o.NULL_EXPR;
   if (view.genConfig.genDebugInfo) {
@@ -458,9 +434,6 @@ function createViewClass(
   if (view.genConfig.genDebugInfo) {
     superConstructorArgs.push(nodeDebugInfosVar);
   }
-  var viewConstructor = new o.ClassMethod(
-      null, viewConstructorArgs, [o.SUPER_EXPR.callFn(superConstructorArgs).toStmt()]);
-
   var viewMethods = [
     new o.ClassMethod(
         'createInternal', [new o.FnParam(rootSelectorVar.name, o.STRING_TYPE)],
@@ -481,12 +454,16 @@ function createViewClass(
     new o.ClassMethod('dirtyParentQueriesInternal', [], view.dirtyParentQueriesMethod.finish()),
     new o.ClassMethod('destroyInternal', [], view.destroyMethod.finish()),
     new o.ClassMethod('detachInternal', [], view.detachMethod.finish())
-  ].concat(view.eventHandlerMethods);
+  ].filter((method) => method.body.length > 0);
   var superClass = view.genConfig.genDebugInfo ? Identifiers.DebugAppView : Identifiers.AppView;
-  var viewClass = new o.ClassStmt(
-      view.className, o.importExpr(resolveIdentifier(superClass), [getContextType(view)]),
-      view.fields, view.getters, viewConstructor,
-      viewMethods.filter((method) => method.body.length > 0));
+
+  var viewClass = createClassStmt({
+    name: view.className,
+    parent: o.importExpr(resolveIdentifier(superClass), [getContextType(view)]),
+    parentArgs: superConstructorArgs,
+    ctorParams: viewConstructorArgs,
+    builders: [{methods: viewMethods}, view]
+  });
   return viewClass;
 }
 
@@ -581,8 +558,8 @@ function generateDetectChangesMethod(view: CompileView): o.Statement[] {
       view.updateViewQueriesMethod.isEmpty() && view.afterViewLifecycleCallbacksMethod.isEmpty()) {
     return stmts;
   }
-  ListWrapper.addAll(stmts, view.animationBindingsMethod.finish());
-  ListWrapper.addAll(stmts, view.detectChangesInInputsMethod.finish());
+  stmts.push(...view.animationBindingsMethod.finish());
+  stmts.push(...view.detectChangesInInputsMethod.finish());
   stmts.push(
       o.THIS_EXPR.callMethod('detectContentChildrenChanges', [DetectChangesVars.throwOnChange])
           .toStmt());
@@ -591,7 +568,7 @@ function generateDetectChangesMethod(view: CompileView): o.Statement[] {
   if (afterContentStmts.length > 0) {
     stmts.push(new o.IfStmt(o.not(DetectChangesVars.throwOnChange), afterContentStmts));
   }
-  ListWrapper.addAll(stmts, view.detectChangesRenderPropertiesMethod.finish());
+  stmts.push(...view.detectChangesRenderPropertiesMethod.finish());
   stmts.push(o.THIS_EXPR.callMethod('detectViewChildrenChanges', [DetectChangesVars.throwOnChange])
                  .toStmt());
   var afterViewStmts =
@@ -610,12 +587,7 @@ function generateDetectChangesMethod(view: CompileView): o.Statement[] {
         DetectChangesVars.changes.set(o.NULL_EXPR)
             .toDeclStmt(new o.MapType(o.importType(resolveIdentifier(Identifiers.SimpleChange)))));
   }
-  if (readVars.has(DetectChangesVars.valUnwrapper.name)) {
-    varStmts.push(
-        DetectChangesVars.valUnwrapper
-            .set(o.importExpr(resolveIdentifier(Identifiers.ValueUnwrapper)).instantiate([]))
-            .toDeclStmt(null, [o.StmtModifier.Final]));
-  }
+  varStmts.push(...createSharedBindingVariablesIfNeeded(stmts));
   return varStmts.concat(stmts);
 }
 

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

@@ -12,30 +12,34 @@ import {AnimationEntryCompileResult} from '../animation/animation_compiler';
 import {CompileDirectiveMetadata, CompilePipeMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import * as o from '../output/output_ast';
+import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {TemplateAst} from '../template_parser/template_ast';
 
 import {CompileElement} from './compile_element';
 import {CompileView} from './compile_view';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewFactoryDependency} from './deps';
 import {bindView} from './view_binder';
-import {ComponentFactoryDependency, ViewFactoryDependency, buildView, finishView} from './view_builder';
+import {buildView, finishView} from './view_builder';
 
-export {ComponentFactoryDependency, ViewFactoryDependency} from './view_builder';
+export {ComponentFactoryDependency, DirectiveWrapperDependency, ViewFactoryDependency} from './deps';
 
 export class ViewCompileResult {
   constructor(
       public statements: o.Statement[], public viewFactoryVar: string,
-      public dependencies: Array<ViewFactoryDependency|ComponentFactoryDependency>) {}
+      public dependencies:
+          Array<ViewFactoryDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {}
 }
 
 @Injectable()
 export class ViewCompiler {
-  constructor(private _genConfig: CompilerConfig) {}
+  constructor(private _genConfig: CompilerConfig, private _schemaRegistry: ElementSchemaRegistry) {}
 
   compileComponent(
       component: CompileDirectiveMetadata, template: TemplateAst[], styles: o.Expression,
       pipes: CompilePipeMetadata[],
       compiledAnimations: AnimationEntryCompileResult[]): ViewCompileResult {
-    const dependencies: Array<ViewFactoryDependency|ComponentFactoryDependency> = [];
+    const dependencies:
+        Array<ViewFactoryDependency|ComponentFactoryDependency|DirectiveWrapperDependency> = [];
     const view = new CompileView(
         component, this._genConfig, pipes, styles, compiledAnimations, 0,
         CompileElement.createNull(), []);
@@ -44,7 +48,7 @@ export class ViewCompiler {
     buildView(view, template, dependencies);
     // Need to separate binding from creation to be able to refer to
     // variables that have been declared after usage.
-    bindView(view, template);
+    bindView(view, template, this._schemaRegistry);
     finishView(view, statements);
 
     return new ViewCompileResult(statements, view.viewFactory.name, dependencies);

modules/@angular/compiler/test/compiler_util/identifier_util_spec.ts

@@ -0,0 +1,63 @@
+/**
+ * @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 {createInlineArray} from '../../src/compiler_util/identifier_util';
+import {Identifiers, resolveIdentifier} from '../../src/identifiers';
+import * as o from '../../src/output/output_ast';
+
+export function main() {
+  describe('createInlineArray', () => {
+
+    function check(argCount: number, expectedIdentifier: any) {
+      const args = createArgs(argCount);
+      expect(createInlineArray(args))
+          .toEqual(o.importExpr(resolveIdentifier(expectedIdentifier)).instantiate([
+            <o.Expression>o.literal(argCount)
+          ].concat(args)));
+    }
+
+    function createArgs(count: number): o.Expression[] {
+      const result: o.Expression[] = [];
+      for (var i = 0; i < count; i++) {
+        result.push(o.NULL_EXPR);
+      }
+      return result;
+    }
+
+    it('should work for arrays of length 0', () => {
+      expect(createInlineArray([
+      ])).toEqual(o.importExpr(resolveIdentifier(Identifiers.EMPTY_INLINE_ARRAY)));
+    });
+
+    it('should work for arrays of length 1 - 2', () => {
+      check(1, Identifiers.inlineArrays[0]);
+      check(2, Identifiers.inlineArrays[1]);
+    });
+
+    it('should work for arrays of length 3 - 4', () => {
+      for (var i = 3; i <= 4; i++) {
+        check(i, Identifiers.inlineArrays[2]);
+      }
+    });
+
+    it('should work for arrays of length 5 - 8', () => {
+      for (var i = 5; i <= 8; i++) {
+        check(i, Identifiers.inlineArrays[3]);
+      }
+    });
+
+    it('should work for arrays of length 9 - 16', () => {
+      for (var i = 9; i <= 16; i++) {
+        check(i, Identifiers.inlineArrays[4]);
+      }
+    });
+
+    it('should work for arrays of length > 16',
+       () => { check(17, Identifiers.InlineArrayDynamic); });
+  });
+}

modules/@angular/compiler/test/expression_parser/parser_spec.ts

@@ -74,7 +74,10 @@ export function main() {
         return;
       }
     }
-    throw Error(`Expected an error containing "${message}" to be reported`);
+    const errMsgs = ast.errors.map(err => err.message).join('\n');
+    throw Error(
+        `Expected an error containing "${message}" to be reported, but got the errors:\n` +
+        errMsgs);
   }
 
   function expectActionError(text: string, message: string) {
@@ -504,16 +507,10 @@ export function main() {
         validate(p);
       });
 
-      it('should parse a constant', () => {
-        var p = parseSimpleBinding('[1, 2]');
-        expect(unparse(p)).toEqual('[1, 2]');
-        validate(p);
-      });
-
-      it('should report when the given expression is not just a field name', () => {
+      it('should report when encountering pipes', () => {
         expectError(
-            validate(parseSimpleBinding('name + 1')),
-            'Host binding expression can only contain field access and constants');
+            validate(parseSimpleBinding('a | somePipe')),
+            'Host binding expression cannot contain pipes');
       });
 
       it('should report when encountering interpolation', () => {
@@ -521,6 +518,10 @@ export function main() {
             validate(parseSimpleBinding('{{exp}}')),
             'Got interpolation ({{}}) where expression was expected');
       });
+
+      it('should report when encountering field write', () => {
+        expectError(validate(parseSimpleBinding('a = b')), 'Bindings cannot contain assignments');
+      });
     });
 
     describe('wrapLiteralPrimitive', () => {

modules/@angular/compiler/test/expression_parser/unparser.ts

@@ -7,7 +7,6 @@
  */
 
 import {AST, AstVisitor, Binary, BindingPipe, Chain, Conditional, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead} from '../../src/expression_parser/ast';
-import {isString} from '../../src/facade/lang';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../../src/ml_parser/interpolation_config';
 
 class Unparser implements AstVisitor {
@@ -133,7 +132,7 @@ class Unparser implements AstVisitor {
   }
 
   visitLiteralPrimitive(ast: LiteralPrimitive, context: any) {
-    if (isString(ast.value)) {
+    if (typeof ast.value === 'string') {
       this._expression += `"${ast.value.replace( Unparser._quoteRegExp,  '\"')}"`;
     } else {
       this._expression += `${ast.value}`;

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

@@ -11,7 +11,7 @@
 import {TypeScriptEmitter} from '@angular/compiler/src/output/ts_emitter';
 
 import {print} from '../../src/facade/lang';
-import {assetUrl} from '../../src/util';
+import {assetUrl} from '../../src/identifiers';
 
 function unimplemented(): any {
   throw new Error('unimplemented');