docs(changelog): update change log to beta.2

.gitignore

@@ -22,7 +22,6 @@ tmp
 *.js.map
 
 # Or type definitions we mirror from github
-# (NB: these lines are removed in publish-build-artifacts.sh)
 **/typings/**/*.d.ts
 **/typings/tsd.cached.json
 

.travis.yml

@@ -36,13 +36,12 @@ env:
   matrix:
     # Order: a slower build first, so that we don't occupy an idle travis worker waiting for others to complete.
     - MODE=dart DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION
-    # Disable dart dev build, which is timing out after 2h. #6823
-    # - MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=saucelabs_required DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=browserstack_required DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=saucelabs_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=browserstack_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
-    - MODE=dart_ddc DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
+    - MODE=dart_experimental DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=js DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=router DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION
     - MODE=build_only DART_CHANNEL=stable DART_VERSION=$DART_STABLE_VERSION
@@ -53,6 +52,7 @@ matrix:
   allow_failures:
   - env: "MODE=saucelabs_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
   - env: "MODE=browserstack_optional DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
+  - env: "MODE=dart_experimental DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
   # TODO(alxhub): remove when dartdoc #1039 is in dev channel
   - env: "MODE=dart DART_CHANNEL=dev DART_VERSION=$DART_DEV_VERSION"
 

CHANGELOG.md

@@ -1,145 +1,3 @@
-<a name="2.0.0-beta.6"></a>
-# 2.0.0-beta.6 (2016-02-11)
-
-
-### Bug Fixes
-
-* **angular1-router:** add missing wrapper methods ([55122cd](https://github.com/angular/angular/commit/55122cd)), closes [#6763](https://github.com/angular/angular/issues/6763) [#6861](https://github.com/angular/angular/issues/6861) [#6861](https://github.com/angular/angular/issues/6861)
-* **angular1-router:** add support for using the component helper ([d86be24](https://github.com/angular/angular/commit/d86be24)), closes [angular/angular.js#13860](https://github.com/angular/angular.js/issues/13860) [#6076](https://github.com/angular/angular/issues/6076) [#5278](https://github.com/angular/angular/issues/5278)
-* **async:** handle synchronous initial value in async pipe ([26e60d6](https://github.com/angular/angular/commit/26e60d6)), closes [#5996](https://github.com/angular/angular/issues/5996)
-* **build:** don't try to copy .d.ts files into the npm distro ([16b5217](https://github.com/angular/angular/commit/16b5217)), closes [#6921](https://github.com/angular/angular/issues/6921)
-* **compiler:** fix interpolation regexp ([9b0e10e](https://github.com/angular/angular/commit/9b0e10e)), closes [#6056](https://github.com/angular/angular/issues/6056)
-* **compiler:** use event names for matching directives ([231773e](https://github.com/angular/angular/commit/231773e)), closes [#6870](https://github.com/angular/angular/issues/6870)
-* **core:** add detail to dehydrated detector exception ([e7ad03c](https://github.com/angular/angular/commit/e7ad03c)), closes [#6939](https://github.com/angular/angular/issues/6939)
-* **core:** mute mode printing in console in prod mode ([74be3d3](https://github.com/angular/angular/commit/74be3d3)), closes [#6873](https://github.com/angular/angular/issues/6873)
-* **di:** throw if a token uses more than 20 dependencies. ([de77700](https://github.com/angular/angular/commit/de77700)), closes [#6690](https://github.com/angular/angular/issues/6690) [#6869](https://github.com/angular/angular/issues/6869)
-* **forms:** add RadioButtonValueAccessor to the list of default value accessors ([8f47aa3](https://github.com/angular/angular/commit/8f47aa3))
-* **forms:** add support for radio buttons ([e725542](https://github.com/angular/angular/commit/e725542)), closes [#6877](https://github.com/angular/angular/issues/6877)
-* **forms:** use strict runtimeType checks instead of instanceof ([50548fb](https://github.com/angular/angular/commit/50548fb)), closes [#6981](https://github.com/angular/angular/issues/6981)
-* **Headers:** serializable toJSON ([b55f176](https://github.com/angular/angular/commit/b55f176)), closes [#6073](https://github.com/angular/angular/issues/6073) [#6714](https://github.com/angular/angular/issues/6714)
-* **ngFor:** update view locals if identity changes ([0f10624](https://github.com/angular/angular/commit/0f10624)), closes [#6923](https://github.com/angular/angular/issues/6923)
-* **router:** Added route data to normalized async route ([df7885c](https://github.com/angular/angular/commit/df7885c)), closes [#6802](https://github.com/angular/angular/issues/6802)
-* **router:** don't prepend `/` unnecessarily to Location paths ([c603643](https://github.com/angular/angular/commit/c603643)), closes [#6729](https://github.com/angular/angular/issues/6729) [#5502](https://github.com/angular/angular/issues/5502)
-* **router:** fix incorrect url param value coercion of 1 to true ([995a9e0](https://github.com/angular/angular/commit/995a9e0)), closes [#5346](https://github.com/angular/angular/issues/5346) [#6286](https://github.com/angular/angular/issues/6286)
-* **router:** fix url path for star segment in path recognizer ([6f1ef33](https://github.com/angular/angular/commit/6f1ef33)), closes [#6976](https://github.com/angular/angular/issues/6976)
-* **router:** fixed the location wrapper for angular1 ([e73fee7](https://github.com/angular/angular/commit/e73fee7)), closes [#6943](https://github.com/angular/angular/issues/6943)
-* **typings:** Don't expose typing dependencies to users. ([2a70f4e](https://github.com/angular/angular/commit/2a70f4e)), closes [#5973](https://github.com/angular/angular/issues/5973) [#5807](https://github.com/angular/angular/issues/5807) [#6266](https://github.com/angular/angular/issues/6266) [#5242](https://github.com/angular/angular/issues/5242) [#6817](https://github.com/angular/angular/issues/6817) [#6267](https://github.com/angular/angular/issues/6267)
-* **upgrade:** fix infinite $rootScope.$digest() ([7e0f02f](https://github.com/angular/angular/commit/7e0f02f)), closes [#6385](https://github.com/angular/angular/issues/6385) [#6386](https://github.com/angular/angular/issues/6386)
-* **Validators:** fix Validators.required marking number zero as invalid ([c2ceb7f](https://github.com/angular/angular/commit/c2ceb7f)), closes [#6617](https://github.com/angular/angular/issues/6617)
-* **WebWorkers:** Fix flaky WebWorker test ([da1fcfd](https://github.com/angular/angular/commit/da1fcfd)), closes [#6851](https://github.com/angular/angular/issues/6851)
-
-### Features
-
-* **angular1_router:** allow component to bind to router ([0f22dce](https://github.com/angular/angular/commit/0f22dce))
-* **typings:** install es6-shim typings to a location users can reference. ([f1f5b45](https://github.com/angular/angular/commit/f1f5b45))
-
-### BREAKING CHANGES
-
-Transitive typings are no longer included in the distribution.
-
-If you use `--target=es5`, you will need to add a line somewhere in your
-application (for example, at the top of the `.ts` file where you call `bootstrap`):
-```
-///<reference path="node_modules/angular2/typings/browser.d.ts"/>
-```
-(Note that if your file is not in the same directory as `node_modules`, you'll
-need to add one or more `../` to the start of that path.)
-
-If you have unit tests, you need to install typings in your project using
-http://github.com/typings/typings
-And install typings such as `jasmine`, `angular-protractor`, or `selenium-webdriver`
-to satisfy the type-checker.
-
-If you rely on es6 APIs other than Promises and Collections, you will need to
-install the es6-shim typing instead of using the <reference> tag above.
-Angular previously exposed typings for the entire ES6 API.
-
-<a name="2.0.0-beta.5"></a>
-# 2.0.0-beta.5 (2016-02-10)
-
-This release was incorrect; replaced with beta.6.
-
-<a name="2.0.0-beta.4"></a>
-# 2.0.0-beta.4 (2016-02-10)
-
-This release was incorrect; replaced with beta.6.
-
-<a name="2.0.0-beta.3"></a>
-# 2.0.0-beta.3 (2016-02-03)
-
-
-### Bug Fixes
-
-* **bundle:** add angular2/platform/testing/browser to SystemJS testing bundle ([ae7d2ab](https://github.com/angular/angular/commit/ae7d2ab))
-* **circle:** pre-dependencies `npm install npm` ([36a0e04](https://github.com/angular/angular/commit/36a0e04)), closes [#6777](https://github.com/angular/angular/issues/6777)
-* **dart/transform:** Handle edge cases in ReflectionRemover ([3e9b532](https://github.com/angular/angular/commit/3e9b532)), closes [#6749](https://github.com/angular/angular/issues/6749)
-* **docs:** `rxjs/add/operators/map` -> `rxjs/add/operator/map` (no 's'). ([2a302aa](https://github.com/angular/angular/commit/2a302aa))
-* **karma:** fix running karma via gulp ([27daeaf](https://github.com/angular/angular/commit/27daeaf))
-* **query:** don’t cross component boundaries ([c6adbf6](https://github.com/angular/angular/commit/c6adbf6)), closes [#6759](https://github.com/angular/angular/issues/6759)
-* **query:** update view queries that query directives in embedded views ([1f7a41c](https://github.com/angular/angular/commit/1f7a41c)), closes [#6747](https://github.com/angular/angular/issues/6747)
-* **WebWorkers:** Add support for transitionend events. ([c2a38c0](https://github.com/angular/angular/commit/c2a38c0)), closes [#6649](https://github.com/angular/angular/issues/6649)
-* **zone:** correct incorrect calls to zone ([3211938](https://github.com/angular/angular/commit/3211938))
-
-### Features
-
-* **change_detection:** allow all legal programs in the dev mode ([42231f5](https://github.com/angular/angular/commit/42231f5))
-* **dart/transform:** Generate all code into <file>.template.dart ([8c36aa8](https://github.com/angular/angular/commit/8c36aa8))
-* **debug:** replace DebugElement with new Debug DOM ([e1bf3d3](https://github.com/angular/angular/commit/e1bf3d3))
-* **ngFor:** add custom trackBy function support ([cee2318](https://github.com/angular/angular/commit/cee2318)), closes [#6779](https://github.com/angular/angular/issues/6779)
-* **upgrade:** support bindToController with binding definitions ([99e6500](https://github.com/angular/angular/commit/99e6500)), closes [#4784](https://github.com/angular/angular/issues/4784)
-* **WebWorker:** Add Router Support for WebWorker Apps ([8bea667](https://github.com/angular/angular/commit/8bea667)), closes [#3563](https://github.com/angular/angular/issues/3563)
-
-### Performance Improvements
-
-* **dart/transform:** Only process deferred libs when necessary ([f56df65](https://github.com/angular/angular/commit/f56df65)), closes [#6745](https://github.com/angular/angular/issues/6745)
-
-### BREAKING CHANGES
-
-This is a breaking change for unit tests. The API for the DebugElement
-has changed. Now, there is a DebugElement or DebugNode for every node
-in the DOM, not only nodes with an ElementRef. `componentViewChildren` is
-removed, and `childNodes` is a list of ElementNodes corresponding to every
-child in the DOM. `query` no longer takes a scope parameter, since
-the entire rendered DOM is included in the `childNodes`.
-
-Before:
-
-```
-componentFixture.debugElement.componentViewChildren[0];
-```
-
-After
-```
-// Depending on the DOM structure of your component, the
-// index may have changed or the first component child
-// may be a sub-child.
-componentFixture.debugElement.children[0];
-```
-
-Before:
-
-```
-debugElement.query(By.css('div'), Scope.all());
-```
-
-After:
-
-```
-debugElement.query(By.css('div'));
-```
-
-Before:
-
-```
-componentFixture.debugElement.elementRef;
-```
-
-After:
-
-```
-componentFixture.elementRef;
-```
-
 <a name="2.0.0-beta.2"></a>
 # 2.0.0-beta.2 (2016-01-28)
 
@@ -172,10 +30,13 @@ componentFixture.elementRef;
 
 ### BREAKING CHANGES
 
+* there's a chance of breakage as router's Instruction constructor
+  signature changed.
+
 * `Renderer.listen` now has to return a function that
   removes the event listener.
 
-* TemplateRef.elementRef is now read-only.
+* remove TemplateRef.elementRef setter
 
 * Tests are now required to use `setBaseTestProviders`
 to set up. Assuming your tests are run on a browser, setup would change
@@ -198,6 +59,7 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
                      TEST_BROWSER_APPLICATION_PROVIDERS);
 ```
 
+* This is very unlikely to be breaking, but I'm still marking just in case. The only change to the user should be that dev mode is driven by Dart's checked mode, like it was in the past.
 
 <a name="2.0.0-beta.1"></a>
 # 2.0.0-beta.1 catamorphic-involution (2016-01-08)
@@ -244,7 +106,6 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
   take a native element instead of an ElementRef
 * `Renderer` interface now operates on plain native nodes,
   instead of `RenderElementRef`s or `RenderViewRef`s
-
 <a name="2.0.0-beta.0"></a>
 # 2.0.0-beta.0 somnambulant-inauguration (2015-12-15)
 
@@ -266,7 +127,10 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
 
 ### BREAKING CHANGES
 
-* Previously, Angular would run in dev prod mode by default, and you could enable the dev mode by calling enableDevMode. Now, Angular runs in the dev mode by default, and you can enable the prod mode by calling enableProdMode.
+* Before
+Previously Angular would run in dev prod mode by default, and you could enable the dev mode by calling enableDevMode.
+After
+Now, Angular runs in the dev mode by default, and you can enable the prod mode by calling enableProdMode.
 
 
 
@@ -343,11 +207,11 @@ bundle. `ngUpgrade` has a dedicated `upgrade.js` bundle now.
 
 * `Observable` are no more re-exported from `angular2/core`
 
-    Before
+    Before 
     ```
     import {Observable} from 'angular2/core'
     ```
-    After
+    After 
     ```
     import {Observable} from 'rxjs/Observable';
     ```
@@ -568,7 +432,7 @@ import * as core from 'angular2/core';
 * Operators and Observables from RxJS (e.g. .map(), .toArray(), .toPromise(), etc ) now need to be explicitly imported (once per operator in your app)
   ```
   import {Observable} from 'rxjs/Observable';
-  import 'rxjs/add/operator/map';
+  import 'rxjs/add/operators/map';
   import 'rxjs/add/observable/interval';
 
   Observable.interval(1000).subscribe(...);

DEVELOPER.md

@@ -9,7 +9,7 @@ JS and Dart versions. It also explains the basic mechanics of using `git`, `node
 * [Installing NPM Modules and Dart Packages](#installing-npm-modules-and-dart-packages)
 * [Build commands](#build-commands)
 * [Running Tests Locally](#running-tests-locally)
-* [Code Style](#code-style)
+* [Formatting](#clang-format)
 * [Project Information](#project-information)
 * [CI using Travis](#ci-using-travis)
 * [Transforming Dart code](#transforming-dart-code)
@@ -227,9 +227,7 @@ Angular specific command line options when running protractor:
 Angular specific command line options when running protractor (e.g. force gc, ...):
 `$(npm bin)/protractor protractor-{js|dart2js}-conf.js --ng-help`
 
-## Code Style
-
-### Formatting with <a name="clang-format">clang-format</a>
+## Formatting with <a name="clang-format">clang-format</a>
 
 We use [clang-format](http://clang.llvm.org/docs/ClangFormat.html) to automatically enforce code
 style for our TypeScript code. This allows us to focus our code reviews more on the content, and
@@ -275,14 +273,6 @@ to some whitespace difference.
 * `clang-format` integrations are also available for many popular editors (`vim`, `emacs`,
   `Sublime Text`, etc.).
 
-### Linting
-
-We use [tslint](https://github.com/palantir/tslint) for linting. See linting rules in [gulpfile](gulpfile.js). To lint, run
-
-```shell
-$ gulp lint
-```
-
 ## Generating the API documentation
 
 The following gulp task will generate the API docs in the `dist/angular.io/partials/api/angular2`:  

circle.yml

@@ -1,21 +1,6 @@
 machine:
   node:
     version: 5.4.1
-
-dependencies:
-  pre:
-    - npm install -g npm
-  override:
-    - npm install:
-        environment:
-          # Token for tsd to increase github rate limit
-          # See https://github.com/DefinitelyTyped/tsd#tsdrc
-          # This is not hidden using https://circleci.com/docs/fork-pr-builds#details
-          # because those are not visible for pull requests, and those should also be reliable.
-          # This SSO token belongs to github account angular-github-ratelimit-token which has no access
-          # (password is in Valentine)
-          TSD_GITHUB_TOKEN: ef474500309daea53d5991b3079159a29520a40b
-
 test:
   override:
     - npm run build

gulpfile.js

@@ -155,7 +155,7 @@ var HTTP_BUNDLE_CONTENT = 'angular2/http - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.j
 var ROUTER_BUNDLE_CONTENT = 'angular2/router + angular2/router/router_link_dsl - rxjs/* - ' +
                             ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var TESTING_BUNDLE_CONTENT =
-    'angular2/testing + angular2/http/testing + angular2/router/testing + angular2/platform/testing/browser - rxjs/* - ' +
+    'angular2/testing + angular2/http/testing + angular2/router/testing - rxjs/* - ' +
     ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var UPGRADE_BUNDLE_CONTENT = 'angular2/upgrade - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 
@@ -463,7 +463,7 @@ function runKarma(configFile, done) {
 
 gulp.task('test.js', function(done) {
   runSequence('test.unit.tools/ci', 'test.transpiler.unittest', 'test.unit.js/ci',
-              'test.unit.cjs/ci', 'test.typings', 'check-public-api', sequenceComplete(done));
+              'test.unit.cjs/ci', 'test.typings', sequenceComplete(done));
 });
 
 gulp.task('test.dart', function(done) {
@@ -627,11 +627,7 @@ gulp.task('!test.unit.router/karma-run', function(done) {
                    });
 });
 
-gulp.task('buildRouter.dev', function() {
-  var modulesSrcDir = __dirname + '/modules';
-  var distDir = __dirname + '/dist';
-  buildRouter(modulesSrcDir, distDir);
-});
+gulp.task('buildRouter.dev', function() { buildRouter(); });
 
 gulp.task('test.unit.dart', function(done) {
   printModulesWarning();
@@ -830,7 +826,7 @@ gulp.task('test.unit.js/ci', function(done) {
                  reporters: ['dots'],
                  browsers: browserConf.browsersToRun
                },
-               function(err) { done(); })
+               done)
       .start();
 });
 
@@ -870,8 +866,6 @@ gulp.task('test.unit.cjs/ci', function(done) {
   runJasmineTests(['dist/js/cjs/{angular2,benchpress}/test/**/*_spec.js'], done);
 });
 
-gulp.task('check-public-api',
-          function(done) { runJasmineTests(['dist/tools/public_api_guard/**/*_spec.js'], done); });
 
 gulp.task('test.unit.cjs', ['build/clean.js', 'build.tools'], function(neverDone) {
   var watch = require('./tools/build/watch');
@@ -981,16 +975,15 @@ gulp.task('!pre.test.typings.layoutNodeModule', ['build.js.cjs'], function() {
       .pipe(gulp.dest(path.join(tmpdir, 'node_modules')));
 });
 gulp.task('!pre.test.typings.copyTypingsSpec', function() {
-  return gulp.src(['typing_spec/*.ts'], {base: 'typing_spec'}).pipe(gulp.dest(tmpdir));
+  return gulp.src(['typing_spec/*.ts'], {base: 'typing_spec'}).pipe(gulp.dest(path.join(tmpdir)));
 });
-
 gulp.task('test.typings',
           ['!pre.test.typings.layoutNodeModule', '!pre.test.typings.copyTypingsSpec'], function() {
             var tsc = require('gulp-typescript');
 
-            return gulp.src([tmpdir + '/*.ts'])
+            return gulp.src([tmpdir + '/**'])
                 .pipe(tsc({
-                  target: 'ES6',
+                  target: 'ES5',
                   module: 'commonjs',
                   experimentalDecorators: true,
                   noImplicitAny: true,

modules/angular1_router/build.js

@@ -21,25 +21,18 @@ var files = [
 
 var PRELUDE = '(function(){\n';
 var POSTLUDE = '\n}());\n';
+var FACADES = fs.readFileSync(__dirname + '/lib/facades.es5', 'utf8');
+var DIRECTIVES = fs.readFileSync(__dirname + '/src/ng_outlet.ts', 'utf8');
+var moduleTemplate = fs.readFileSync(__dirname + '/src/module_template.js', 'utf8');
 
-function main(modulesDirectory) {
-  var angular1RouterModuleDirectory = modulesDirectory + '/angular1_router';
-
-  var facades = fs.readFileSync(
-      angular1RouterModuleDirectory + '/lib/facades.es5', 'utf8');
-  var directives = fs.readFileSync(
-      angular1RouterModuleDirectory + '/src/ng_outlet.ts', 'utf8');
-  var moduleTemplate = fs.readFileSync(
-      angular1RouterModuleDirectory + '/src/module_template.js', 'utf8');
-
-  var dir = modulesDirectory + '/angular2/src/router/';
+function main() {
+  var dir = __dirname + '/../angular2/src/router/';
   var sharedCode = files.reduce(function (prev, file) {
     return prev + transform(fs.readFileSync(dir + file, 'utf8'));
   }, '');
 
-  var out = moduleTemplate.replace('//{{FACADES}}', facades)
-                .replace('//{{SHARED_CODE}}', sharedCode);
-  return PRELUDE + transform(directives) + out + POSTLUDE;
+  var out = moduleTemplate.replace('//{{FACADES}}', FACADES).replace('//{{SHARED_CODE}}', sharedCode);
+  return PRELUDE + transform(DIRECTIVES) + out + POSTLUDE;
 }
 
 /*
@@ -69,29 +62,10 @@ function isFacadeModule(modulePath) {
     modulePath === 'angular2/src/core/reflection/reflection';
 }
 
-module.exports = function(modulesDirectory, outputDirectory) {
-  if (!fs.existsSync(outputDirectory)) {
-    fs.mkdirSync(outputDirectory);
+module.exports = function () {
+  var dist = __dirname + '/../../dist';
+  if (!fs.existsSync(dist)) {
+    fs.mkdirSync(dist);
   }
-  fs.writeFileSync(
-      outputDirectory + '/angular_1_router.js', main(modulesDirectory));
+  fs.writeFileSync(dist + '/angular_1_router.js', main());
 };
-
-// CLI entry point
-if (require.main === module) {
-  try {
-    var args = process.argv;
-    args.shift();  // node
-    args.shift();  // scriptfile.js
-    if (args.length < 2) {
-      console.log("usage: $0 outFile path/to/modules");
-      process.exit(1);
-    }
-    var outfile = args.shift();
-    var directory = args.shift();
-    fs.writeFileSync(outfile, main(directory));
-  } catch (e) {
-    console.log(e.message);
-    process.exit(1);
-  }
-}

modules/angular1_router/lib/facades.es5

@@ -173,10 +173,6 @@ var StringMapWrapper = {
 
 var List = Array;
 var ListWrapper = {
-  toJSON: function(l) {
-    return JSON.stringify(l);
-  },
-
   clear: function (l) {
     l.length = 0;
   },
@@ -251,10 +247,6 @@ var ListWrapper = {
 };
 
 var StringWrapper = {
-  charCodeAt: function(s, i) {
-    return s.charCodeAt(i);
-  },
-
   equals: function (s1, s2) {
     return s1 === s2;
   },
@@ -311,8 +303,8 @@ Location.prototype.subscribe = function () {
   //TODO: implement
 };
 Location.prototype.path = function () {
-  return $location.url();
+  return $location.path();
 };
-Location.prototype.go = function (path, query) {
-  return $location.url(path + query);
+Location.prototype.go = function (url) {
+  return $location.path(url);
 };

modules/angular1_router/src/module_template.js

@@ -57,7 +57,7 @@ function routerFactory($q, $location, $$directiveIntrospector, $browser, $rootSc
   });
 
   var router = new RootRouter(registry, location, $routerRootComponent);
-  $rootScope.$watch(function () { return $location.url(); }, function (path) {
+  $rootScope.$watch(function () { return $location.path(); }, function (path) {
     if (router.lastNavigationAttempt !== path) {
       router.navigateByUrl(path);
     }

modules/angular1_router/src/ng_outlet.ts

@@ -155,12 +155,10 @@ function ngOutletDirective($animate, $q: ng.IQService, $router) {
         }
 
         this.controller.$$routeParams = instruction.params;
-        this.controller.$$template =
-            '<' + dashCase(componentName) + ' router="$$router"></' + dashCase(componentName) + '>';
+        this.controller.$$template = '<div ' + dashCase(componentName) + '></div>';
         this.controller.$$router = this.router.childRouter(instruction.componentType);
 
         let newScope = scope.$new();
-        newScope.$$router = this.controller.$$router;
 
         let clone = $transclude(newScope, clone => {
           $animate.enter(clone, null, this.currentElement || element);

modules/angular1_router/src/ng_route_shim.js

@@ -1,4 +1,4 @@
-/** @license Copyright 2014-2016 Google, Inc. http://github.com/angular/angular/LICENSE */
+/** @license Copyright 2014-2015 Google, Inc. http://github.com/angular/angular/LICENSE */
 (function () {
 
   'use strict';

modules/angular1_router/test/integration/navigation_spec.js

@@ -21,29 +21,17 @@ describe('navigation', function () {
       $router = _$router_;
     });
 
-    registerDirective('userCmp', {
+    registerComponent('userCmp', {
       template: '<div>hello {{userCmp.$routeParams.name}}</div>'
     });
-    registerDirective('oneCmp', {
+    registerComponent('oneCmp', {
       template: '<div>{{oneCmp.number}}</div>',
       controller: function () {this.number = 'one'}
     });
-    registerDirective('twoCmp', {
+    registerComponent('twoCmp', {
       template: '<div>{{twoCmp.number}}</div>',
       controller: function () {this.number = 'two'}
     });
-    registerComponent('threeCmp', {
-      template: '<div>{{$ctrl.number}}</div>',
-      controller: function () {this.number = 'three'}
-    });
-    registerComponent('getParams', {
-      template: '<div>{{$ctrl.params.x}}</div>',
-      controller: function () {
-        this.$routerOnActivate = function(next) {
-          this.params = next.params;
-        };
-      }
-    })
   });
 
   it('should work in a simple case', function () {
@@ -59,21 +47,6 @@ describe('navigation', function () {
     expect(elt.text()).toBe('one');
   });
 
-
-  it('should work with components created by the `mod.component()` helper', function () {
-    compile('<ng-outlet></ng-outlet>');
-
-    $router.config([
-      { path: '/', component: 'threeCmp' }
-    ]);
-
-    $router.navigateByUrl('/');
-    $rootScope.$digest();
-
-    expect(elt.text()).toBe('three');
-  });
-
-
   it('should navigate between components with different parameters', function () {
     $router.config([
       { path: '/user/:name', component: 'userCmp' }
@@ -95,7 +68,7 @@ describe('navigation', function () {
     function ParentController() {
       instanceCount += 1;
     }
-    registerDirective('parentCmp', {
+    registerComponent('parentCmp', {
       template: 'parent { <ng-outlet></ng-outlet> }',
       $routeConfig: [
         { path: '/user/:name', component: 'userCmp' }
@@ -121,7 +94,7 @@ describe('navigation', function () {
 
 
   it('should work with nested outlets', function () {
-    registerDirective('childCmp', {
+    registerComponent('childCmp', {
       template: '<div>inner { <div ng-outlet></div> }</div>',
       $routeConfig: [
         { path: '/b', component: 'oneCmp' }
@@ -139,29 +112,9 @@ describe('navigation', function () {
     expect(elt.text()).toBe('outer { inner { one } }');
   });
 
-  it('should work when parent route has empty path', inject(function ($location) {
-    registerComponent('childCmp', {
-      template: '<div>inner { <div ng-outlet></div> }</div>',
-      $routeConfig: [
-        { path: '/b', component: 'oneCmp' }
-      ]
-    });
-
-    $router.config([
-      { path: '/...', component: 'childCmp' }
-    ]);
-    compile('<div>outer { <div ng-outlet></div> }</div>');
-
-    $router.navigateByUrl('/b');
-    $rootScope.$digest();
-
-    expect(elt.text()).toBe('outer { inner { one } }');
-    expect($location.path()).toBe('/b');
-  }));
-
 
   it('should work with recursive nested outlets', function () {
-    registerDirective('recurCmp', {
+    registerComponent('recurCmp', {
       template: '<div>recur { <div ng-outlet></div> }</div>',
       $routeConfig: [
         { path: '/recur', component: 'recurCmp' },
@@ -194,21 +147,6 @@ describe('navigation', function () {
   }));
 
 
-  it('should pass through query terms to the location', inject(function ($location) {
-    $router.config([
-      { path: '/user', component: 'userCmp' }
-    ]);
-
-    compile('<div ng-outlet></div>');
-
-    $router.navigateByUrl('/user?x=y');
-    $rootScope.$digest();
-
-    expect($location.path()).toBe('/user');
-    expect($location.search()).toEqual({ x: 'y'});
-  }));
-
-
   it('should change location to the canonical route', inject(function ($location) {
     compile('<div ng-outlet></div>');
 
@@ -225,7 +163,7 @@ describe('navigation', function () {
 
 
   it('should change location to the canonical route with nested components', inject(function ($location) {
-    registerDirective('childRouter', {
+    registerComponent('childRouter', {
       template: '<div>inner { <div ng-outlet></div> }</div>',
       $routeConfig: [
         { path: '/new-child', component: 'oneCmp', name: 'NewChild'},
@@ -268,22 +206,9 @@ describe('navigation', function () {
   }));
 
 
-  it('should navigate when the location query changes', inject(function ($location) {
-    $router.config([
-      { path: '/get/params', component: 'getParams' }
-    ]);
-    compile('<div ng-outlet></div>');
-
-    $location.url('/get/params?x=y');
-    $rootScope.$digest();
-
-    expect(elt.text()).toBe('y');
-  }));
-
-
   it('should expose a "navigating" property on $router', inject(function ($q) {
     var defer;
-    registerDirective('pendingActivate', {
+    registerComponent('pendingActivate', {
       $canActivate: function () {
         defer = $q.defer();
         return defer.promise;
@@ -302,26 +227,31 @@ describe('navigation', function () {
     expect($router.navigating).toBe(false);
   }));
 
-  function registerDirective(name, options) {
+  function registerComponent(name, options) {
+    var controller = options.controller || function () {};
+
+    ['$routerOnActivate', '$routerOnDeactivate', '$routerOnReuse', '$routerCanReuse', '$routerCanDeactivate'].forEach(function (hookName) {
+      if (options[hookName]) {
+        controller.prototype[hookName] = options[hookName];
+      }
+    });
+
     function factory() {
       return {
         template: options.template || '',
         controllerAs: name,
-        controller: getController(options)
+        controller: controller
       };
     }
-    applyStaticProperties(factory, options);
-    $compileProvider.directive(name, factory);
-  }
 
-  function registerComponent(name, options) {
-
-    var definition = {
-      template: options.template || '',
-      controller: getController(options),
+    if (options.$canActivate) {
+      factory.$canActivate = options.$canActivate;
     }
-    applyStaticProperties(definition, options);
-    $compileProvider.component(name, definition);
+    if (options.$routeConfig) {
+      factory.$routeConfig = options.$routeConfig;
+    }
+
+    $compileProvider.directive(name, factory);
   }
 
   function compile(template) {
@@ -329,27 +259,4 @@ describe('navigation', function () {
     $rootScope.$digest();
     return elt;
   }
-
-  function getController(options) {
-    var controller = options.controller || function () {};
-    [
-      '$routerOnActivate', '$routerOnDeactivate',
-      '$routerOnReuse', '$routerCanReuse',
-      '$routerCanDeactivate'
-    ].forEach(function (hookName) {
-      if (options[hookName]) {
-        controller.prototype[hookName] = options[hookName];
-      }
-    });
-    return controller;
-  }
-
-  function applyStaticProperties(target, options) {
-    ['$canActivate', '$routeConfig'].forEach(function(property) {
-      if (options[property]) {
-        target[property] = options[property];
-      }
-    });
-  }
 });
-

modules/angular1_router/test/integration/router_spec.js

@@ -44,78 +44,31 @@ describe('router', function () {
     expect(elt.text()).toBe('Home');
   }));
 
-  it('should bind the component to the current router', inject(function($location) {
-    var router;
-    registerComponent('homeCmp', {
-      bindings: { router: '=' },
-      controller: function($scope, $element) {
-        this.$routerOnActivate = function() {
-          router = this.router;
-        };
-      },
-      template: 'Home'
-    });
+  function registerComponent(name, options) {
+    var controller = options.controller || function () {};
 
-    registerComponent('app', {
-      template: '<div ng-outlet></div>',
-      $routeConfig: [
-        { path: '/', component: 'homeCmp' }
-      ]
-    });
-
-    compile('<app></app>');
-
-    $location.path('/');
-    $rootScope.$digest();
-    var homeElement = elt.find('home-cmp');
-    expect(homeElement.text()).toBe('Home');
-    expect(homeElement.isolateScope().$ctrl.router).toBeDefined();
-    expect(router).toBeDefined();
-  }));
-
-  it('should work when an async route is provided route data', inject(function($location, $q) {
-    registerDirective('homeCmp', {
-      template: 'Home ({{homeCmp.isAdmin}})',
-      $routerOnActivate: function(next, prev) {
-        this.isAdmin = next.routeData.data.isAdmin;
+    ['$onActivate', '$onDeactivate', '$onReuse', '$canReuse', '$canDeactivate'].forEach(function (hookName) {
+      if (options[hookName]) {
+        controller.prototype[hookName] = options[hookName];
       }
     });
 
-    registerDirective('app', {
-      template: '<div ng-outlet></div>',
-      $routeConfig: [
-        { path: '/', loader: function() { return $q.when('homeCmp'); }, data: { isAdmin: true } }
-      ]
-    });
-
-    compile('<app></app>');
-
-    $location.path('/');
-    $rootScope.$digest();
-    expect(elt.text()).toBe('Home (true)');
-  }));
-
-  function registerDirective(name, options) {
     function factory() {
       return {
         template: options.template || '',
         controllerAs: name,
-        controller: getController(options)
+        controller: controller
       };
     }
-    applyStaticProperties(factory, options);
-    $compileProvider.directive(name, factory);
-  }
 
-  function registerComponent(name, options) {
-
-    var definition = {
-      bindings: options.bindings,
-      template: options.template || '',
-      controller: getController(options),
+    if (options.$canActivate) {
+      factory.$canActivate = options.$canActivate;
     }
-    applyStaticProperties(definition, options);
-    $compileProvider.component(name, definition);
+    if (options.$routeConfig) {
+      factory.$routeConfig = options.$routeConfig;
+    }
+
+    $compileProvider.directive(name, factory);
   }
 
   function compile(template) {
@@ -123,26 +76,4 @@ describe('router', function () {
     $rootScope.$digest();
     return elt;
   }
-
-  function getController(options) {
-    var controller = options.controller || function () {};
-    [
-      '$routerOnActivate', '$routerOnDeactivate',
-      '$routerOnReuse', '$routerCanReuse',
-      '$routerCanDeactivate'
-    ].forEach(function (hookName) {
-      if (options[hookName]) {
-        controller.prototype[hookName] = options[hookName];
-      }
-    });
-    return controller;
-  }
-
-  function applyStaticProperties(target, options) {
-    ['$canActivate', '$routeConfig'].forEach(function(property) {
-      if (options[property]) {
-        target[property] = options[property];
-      }
-    });
-  }
 });

modules/angular1_router/tsd.json

@@ -1,12 +1,12 @@
 {
   "version": "v4",
-  "repo": "DefinitelyTyped/DefinitelyTyped",
+  "repo": "angular/DefinitelyTyped",
   "ref": "master",
   "path": "typings",
   "bundle": "typings/tsd.d.ts",
   "installed": {
     "angularjs/angular.d.ts": {
-      "commit": "6eebd5e90a1cbd6b47b0705ba72dbcd5baf846f3"
+      "commit": "746b9a892629060bc853e792afff536e0ec4655e"
     }
   }
 }

modules/angular2/core.dart

@@ -15,8 +15,9 @@ export './src/core/application_tokens.dart' show APP_ID,
 export './src/core/zone.dart';
 export './src/core/render.dart';
 export './src/core/linker.dart';
-export './src/core/debug/debug_node.dart' show DebugElement,
-  DebugNode,
+export './src/core/debug/debug_element.dart' show DebugElement,
+  Scope,
+  inspectElement,
   asNativeElements;
 export './src/core/testability/testability.dart';
 export './src/core/change_detection.dart';

modules/angular2/core.ts

@@ -20,7 +20,12 @@ export {
 export * from './src/core/zone';
 export * from './src/core/render';
 export * from './src/core/linker';
-export {DebugElement, DebugNode, asNativeElements} from './src/core/debug/debug_node';
+export {
+  DebugElement,
+  Scope,
+  inspectElement,
+  asNativeElements
+} from './src/core/debug/debug_element';
 export * from './src/core/testability/testability';
 export * from './src/core/change_detection';
 export * from './src/core/platform_directives_and_pipes';

modules/angular2/docs/bundles/overview.md

@@ -32,7 +32,7 @@ filename    | list of barrels   | dev/prod | minified?
 `angular2-all.umd.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade`| prod | no
 `angular2-all.umd.min.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade` | prod | yes
 `angular2-all.umd.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade` | dev | no
-`angular2-all-testing.umd.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade`, `angular2/testing`, `angular2/http/testing`, `angular2/router/testing`, `angular2/platform/testing/browser` | dev | no
+`angular2-all-testing.umd.dev.js` | `angular2/core`, `angular2/common`, `angular2/compiler`, `angular2/platform/browser`, `angular2/platform/common_dom`, `angular2/http`, `angular2/router`, `angular2/instrumentation`, `angular2/upgrade`, `angular2/testing`, `angular2/http/testing`, `angular2/router/testing` | dev | no
 
 **Warning**: bundles in the `UMD` format are _not_ "additive". A single application should use only one bundle from the above list.
 
@@ -55,7 +55,7 @@ filename    | list of barrels   | dev/prod | minified?
 `upgrade.js` | `angular2/upgrade` | prod | no
 `upgrade.min.js` | `angular2/upgrade` | prod | yes
 `upgrade.dev.js` | `angular2/upgrade` | dev | no
-`testing.dev.js` | `angular2/testing`, `angular2/http/testing`, `angular2/router/testing`, `angular2/platform/testing/browser` | dev | no
+`testing.dev.js` | `angular2/testing`, `angular2/http/testing`, `angular2/router/testing` | dev | no
 
 **Note**: bundles in the `System.register` format are "additive" - it is quite common to include several bundles in one application.
 For example people using Angular 2 with `http` and `router` would include: `angular2.js`, `http.js` and `router.js`.

modules/angular2/docs/cheatsheet/bootstrapping.md

@@ -3,7 +3,7 @@ Bootstrapping
 @cheatsheetIndex 0
 @description
 {@target ts}`import {bootstrap} from 'angular2/platform/browser';`{@endtarget}
-{@target js}Available from the `ng.platform.browser` namespace{@endtarget}
+{@target js}Available from the `ng.platform.browser` namespace.{@endtarget}
 {@target dart}`import 'package:angular2/bootstrap.dart';`{@endtarget}
 
 @cheatsheetItem

modules/angular2/docs/cheatsheet/built-in-directives.md

@@ -4,7 +4,7 @@ Built-in directives
 @description
 {@target ts}`import {NgIf, ...} from 'angular2/common';`{@endtarget}
 {@target js}Available from the `ng.common` namespace{@endtarget}
-{@target dart}Available using `platform_directives` in pubspec{@endtarget}
+{@target dart}`import 'package:angular2/common.dart';`{@endtarget}
 
 @cheatsheetItem
 syntax:

modules/angular2/docs/cheatsheet/class-decorators.md

@@ -4,7 +4,7 @@ Class decorators
 @description
 {@target ts}`import {Directive, ...} from 'angular2/core';`{@endtarget}
 {@target js}Available from the `ng.core` namespace{@endtarget}
-{@target dart}`import 'package:angular2/angular2.dart';`{@endtarget}
+{@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
 syntax(ts):

modules/angular2/docs/cheatsheet/dependency-injection.md

@@ -4,7 +4,7 @@ Dependency injection configuration
 @description
 {@target ts}`import {provide} from 'angular2/core';`{@endtarget}
 {@target js}Available from the `ng.core` namespace{@endtarget}
-{@target dart}`import 'package:angular2/angular2.dart';`{@endtarget}
+{@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
 syntax(ts dart):

modules/angular2/docs/cheatsheet/directive-and-component-decorators.md

@@ -4,7 +4,7 @@ Class field decorators for directives and components
 @description
 {@target ts}`import {Input, ...} from 'angular2/core';`{@endtarget}
 {@target js}Available from the `ng.core` namespace{@endtarget}
-{@target dart}`import 'package:angular2/angular2.dart';`{@endtarget}
+{@target dart}`import 'package:angular2/core.dart';`{@endtarget}
 
 @cheatsheetItem
 syntax(ts dart):

modules/angular2/docs/cheatsheet/forms.md

@@ -4,7 +4,7 @@ Forms
 @description
 {@target ts}`import {FORM_DIRECTIVES} from 'angular2/common';`{@endtarget}
 {@target js}Available from `ng.common.FORM_DIRECTIVES`{@endtarget}
-{@target dart}Available using `platform_directives` in pubspec{@endtarget}
+{@target dart}`import 'package:angular2/common.dart';`{@endtarget}
 
 @cheatsheetItem
 syntax:

modules/angular2/docs/cheatsheet/routing.md

@@ -4,22 +4,22 @@ Routing and navigation
 @description
 {@target ts}`import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, ...} from 'angular2/router';`{@endtarget}
 {@target js}Available from the `ng.router` namespace{@endtarget}
-{@target dart}`import 'package:angular2/angular2.dart';`{@endtarget}
+{@target dart}`import 'package:angular2/router.dart';`{@endtarget}
 
 
 @cheatsheetItem
 syntax(ts):
 `@RouteConfig([
-  { path: '/:myParam', component: MyComponent, name: 'MyCmp' },
-  { path: '/staticPath', component: ..., name: ...},
-  { path: '/*wildCardParam', component: ..., name: ...}
+  { path: '/:myParam', component: MyComponent, as: 'MyCmp' },
+  { path: '/staticPath', component: ..., as: ...},
+  { path: '/*wildCardParam', component: ..., as: ...}
 ])
 class MyComponent() {}`|`@RouteConfig`
 syntax(js):
 `var MyComponent = ng.router.RouteConfig([
-  { path: '/:myParam', component: MyComponent, name: 'MyCmp' },
-  { path: '/staticPath', component: ..., name: ...},
-  { path: '/*wildCardParam', component: ..., name: ...}
+  { path: '/:myParam', component: MyComponent, as: 'MyCmp' },
+  { path: '/staticPath', component: ..., as: ...},
+  { path: '/*wildCardParam', component: ..., as: ...}
 ]).Class({
   constructor: function() {}
 });`|`ng.router.RouteConfig`

modules/angular2/docs/core/01_templates.md

@@ -456,7 +456,7 @@ Where
 * `local` is a local identifier for local variables.
 * `internal` is an internal variable which the directive exports for binding.
 * `key` is an attribute name usually only used to trigger a specific directive.
-* `keyExpression` is a property name to which the expression will be bound to.
+* `keyExpression` is an property name to which the expression will be bound to.
 * `varExport` allows exporting of directive internal state as variables for further binding. If no `internal` name
   is specified, the exporting is to an implicit variable.
 * `microsyntax` allows you to build a simple microsyntax which can still clearly identify which expressions bind to

modules/angular2/examples/core/debug/ts/debug_element/debug_element.ts

@@ -1,8 +1,16 @@
-import {DebugElement} from 'angular2/core';
+import {DebugElement, Scope} from 'angular2/core';
 
 var debugElement: DebugElement;
 var predicate;
 
 // #docregion scope_all
-debugElement.query(predicate);
+debugElement.query(predicate, Scope.all);
+// #enddocregion
+
+// #docregion scope_light
+debugElement.query(predicate, Scope.light);
+// #enddocregion
+
+// #docregion scope_view
+debugElement.query(predicate, Scope.view);
 // #enddocregion

modules/angular2/examples/platform/dom/debug/ts/by/by.ts

@@ -1,17 +1,17 @@
 import {By} from 'angular2/platform/browser';
-import {DebugElement} from 'angular2/core';
+import {DebugElement, Scope} from 'angular2/core';
 
 var debugElement: DebugElement;
 class MyDirective {}
 
 // #docregion by_all
-debugElement.query(By.all());
+debugElement.query(By.all(), Scope.all);
 // #enddocregion
 
 // #docregion by_css
-debugElement.query(By.css('[attribute]'));
+debugElement.query(By.css('[attribute]'), Scope.all);
 // #enddocregion
 
 // #docregion by_directive
-debugElement.query(By.directive(MyDirective));
+debugElement.query(By.directive(MyDirective), Scope.all);
 // #enddocregion

modules/angular2/http.ts

@@ -141,8 +141,7 @@ export {URLSearchParams} from './src/http/url_search_params';
  *       // Send a response to the request
  *       connection.mockRespond(response);
  *     });
- *   }
- * });
+ *   });
  *
  * http.get('people.json').observer({
  *   next: res => {
@@ -157,8 +156,7 @@ export const HTTP_PROVIDERS: any[] = [
   // issue: https://github.com/angular/angular/issues/3183
   provide(Http,
           {
-            useFactory: (xhrBackend: XHRBackend, requestOptions: RequestOptions) =>
-                            new Http(xhrBackend, requestOptions),
+            useFactory: (xhrBackend, requestOptions) => new Http(xhrBackend, requestOptions),
             deps: [XHRBackend, RequestOptions]
           }),
   BrowserXhr,
@@ -270,8 +268,7 @@ export const HTTP_BINDINGS = HTTP_PROVIDERS;
  *       // Send a response to the request
  *       connection.mockRespond(response);
  *     });
- *   }
- * });
+ *   });
 
  * jsonp.get('people.json').observer({
  *   next: res => {
@@ -286,8 +283,7 @@ export const JSONP_PROVIDERS: any[] = [
   // issue: https://github.com/angular/angular/issues/3183
   provide(Jsonp,
           {
-            useFactory: (jsonpBackend: JSONPBackend, requestOptions: RequestOptions) =>
-                            new Jsonp(jsonpBackend, requestOptions),
+            useFactory: (jsonpBackend, requestOptions) => new Jsonp(jsonpBackend, requestOptions),
             deps: [JSONPBackend, RequestOptions]
           }),
   BrowserJsonp,

modules/angular2/manual_typings/globals-es6.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Declarations angular depends on for compilation to ES6.
+ * This file is also used to propagate our transitive typings
+ * to users.
+ */
+
+/// <reference path="../typings/zone/zone.d.ts"/>
+/// <reference path="../typings/hammerjs/hammerjs.d.ts"/>
+
+// TODO: ideally the node.d.ts reference should be scoped only for files that need and not to all
+//       the code including client code
+/// <reference path="../typings/node/node.d.ts" />
+
+declare var assert: any;
+
+
+interface BrowserNodeGlobal {
+  Object: typeof Object;
+  Array: typeof Array;
+  Map: typeof Map;
+  Set: typeof Set;
+  Date: typeof Date;
+  RegExp: typeof RegExp;
+  JSON: typeof JSON;
+  Math: typeof Math;
+  assert(condition: any): void;
+  Reflect: any;
+  zone: Zone;
+  getAngularTestability: Function;
+  getAllAngularTestabilities: Function;
+  frameworkStabilizers: Array<Function>;
+  setTimeout: Function;
+  clearTimeout: Function;
+  setInterval: Function;
+  clearInterval: Function;
+}

modules/angular2/manual_typings/globals.d.ts

@@ -1,52 +1,7 @@
 /**
- * Subset of es6-shim typings.
- * Angular should not require use of ES6 runtime but some API usages are already present.
- * See https://github.com/angular/angular/issues/5242
- * TODO(alexeagle): remove methods below which may not be present in targeted browser
+ * Declarations angular depends on for compilation to ES6.
+ * This file is also used to propagate our transitive typings
+ * to users.
  */
-
-declare type PromiseConstructor = typeof Promise;
-
-interface String {
-  /**
-   * Returns true if the sequence of elements of searchString converted to a String is the
-   * same as the corresponding elements of this object (converted to a String) starting at
-   * position. Otherwise returns false.
-   */
-  startsWith(searchString: string, position?: number): boolean;
-
-  /**
-   * Returns true if the sequence of elements of searchString converted to a String is the
-   * same as the corresponding elements of this object (converted to a String) starting at
-   * endPosition – length(this). Otherwise returns false.
-   */
-  endsWith(searchString: string, endPosition?: number): boolean;
-}
-interface Array<T> {
-  /**
-   * Returns the value of the first element in the array where predicate is true, and undefined
-   * otherwise.
-   * @param predicate find calls predicate once for each element of the array, in ascending
-   * order, until it finds one where predicate returns true. If such an element is found, find
-   * immediately returns that element value. Otherwise, find returns undefined.
-   * @param thisArg If provided, it will be used as the this value for each invocation of
-   * predicate. If it is not provided, undefined is used instead.
-   */
-  find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
-  /**
-   * Returns the this object after filling the section identified by start and end with value
-   * @param value value to fill array section with
-   * @param start index to start filling the array at. If start is negative, it is treated as
-   * length+start where length is the length of the array.
-   * @param end index to stop filling the array at. If end is negative, it is treated as
-   * length+end.
-   */
-  fill(value: T, start?: number, end?: number): T[];
-}
-interface NumberConstructor {
-  /**
-   * Returns true if the value passed is an integer, false otherwise.
-   * @param number A numeric value.
-   */
-  isInteger(number: number): boolean;
-}
+/// <reference path="../typings/es6-shim/es6-shim.d.ts"/>
+/// <reference path="./globals-es6.d.ts"/>

modules/angular2/platform/browser.ts

@@ -1,8 +1,8 @@
 export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
 export {
   BROWSER_PROVIDERS,
+  ELEMENT_PROBE_BINDINGS,
   ELEMENT_PROBE_PROVIDERS,
-  ELEMENT_PROBE_PROVIDERS_PROD_MODE,
   inspectNativeElement,
   BrowserDomAdapter,
   By,

modules/angular2/platform/browser_static.ts

@@ -1,8 +1,8 @@
 export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
 export {
   BROWSER_PROVIDERS,
+  ELEMENT_PROBE_BINDINGS,
   ELEMENT_PROBE_PROVIDERS,
-  ELEMENT_PROBE_PROVIDERS_PROD_MODE,
   inspectNativeElement,
   BrowserDomAdapter,
   By,

modules/angular2/platform/common_dom.ts

@@ -12,4 +12,4 @@ export {
   EventManagerPlugin
 } from 'angular2/src/platform/dom/events/event_manager';
 export * from 'angular2/src/platform/dom/debug/by';
-export * from 'angular2/src/platform/dom/debug/ng_probe';
+export * from 'angular2/src/platform/dom/debug/debug_element_view_listener';

modules/angular2/platform/worker_app.dart

@@ -12,5 +12,3 @@ export 'package:angular2/src/web_workers/shared/service_message_broker.dart'
     show ReceivedMessage, ServiceMessageBroker, ServiceMessageBrokerFactory;
 export 'package:angular2/src/web_workers/shared/serializer.dart' show PRIMITIVE;
 export 'package:angular2/src/web_workers/shared/message_bus.dart';
-export 'package:angular2/src/web_workers/worker/router_providers.dart'
-  show WORKER_APP_ROUTER;

modules/angular2/platform/worker_app.ts

@@ -8,13 +8,12 @@ export {
   ClientMessageBrokerFactory,
   FnArg,
   UiArguments
-} from 'angular2/src/web_workers/shared/client_message_broker';
+} from '../src/web_workers/shared/client_message_broker';
 export {
   ReceivedMessage,
   ServiceMessageBroker,
   ServiceMessageBrokerFactory
-} from 'angular2/src/web_workers/shared/service_message_broker';
-export {PRIMITIVE} from 'angular2/src/web_workers/shared/serializer';
-export * from 'angular2/src/web_workers/shared/message_bus';
+} from '../src/web_workers/shared/service_message_broker';
+export {PRIMITIVE} from '../src/web_workers/shared/serializer';
+export * from '../src/web_workers/shared/message_bus';
 export {AngularEntrypoint} from 'angular2/src/core/angular_entrypoint';
-export {WORKER_APP_ROUTER} from 'angular2/src/web_workers/worker/router_providers';

modules/angular2/platform/worker_render.dart

@@ -18,9 +18,7 @@ export '../src/web_workers/shared/service_message_broker.dart'
 
 export '../src/web_workers/shared/serializer.dart' show PRIMITIVE;
 export '../src/web_workers/shared/message_bus.dart';
-export '../src/web_workers/ui/router_providers.dart' show WORKER_RENDER_ROUTER;
 
 import 'package:angular2/src/platform/worker_render_common.dart';
 
 const WORKER_RENDER_APP = WORKER_RENDER_APPLICATION_COMMON;
-

modules/angular2/platform/worker_render.ts

@@ -24,4 +24,3 @@ import {WORKER_RENDER_APPLICATION} from 'angular2/src/platform/worker_render';
  * @deprecated Use WORKER_RENDER_APPLICATION
  */
 export const WORKER_RENDER_APP = WORKER_RENDER_APPLICATION;
-export {WORKER_RENDER_ROUTER} from 'angular2/src/web_workers/ui/router_providers';

modules/angular2/pubspec.yaml

@@ -18,12 +18,12 @@ dependencies:
   logging: '>=0.9.0 <0.12.0'
   observe: '^0.13.1'
   protobuf: '^0.5.0'
+  quiver: '^0.21.4'
   source_span: '^1.0.0'
   stack_trace: '^1.1.1'
 dev_dependencies:
   code_transformers: '>=0.2.9+4 <0.4.0'
   guinness: '^0.1.18'
-  quiver: '^0.21.4'
   test: '^0.12.6'
 transformers:
 - angular2

modules/angular2/router.ts

@@ -20,12 +20,18 @@ export {OnActivate, OnDeactivate, OnReuse, CanDeactivate, CanReuse} from './src/
 export {CanActivate} from './src/router/lifecycle_annotations';
 export {Instruction, ComponentInstruction} from './src/router/instruction';
 export {OpaqueToken} from 'angular2/core';
-export {ROUTER_PROVIDERS_COMMON} from 'angular2/src/router/router_providers_common';
-export {ROUTER_PROVIDERS, ROUTER_BINDINGS} from 'angular2/src/router/router_providers';
 
+import {PlatformLocation} from './src/router/platform_location';
+import {LocationStrategy} from './src/router/location_strategy';
+import {PathLocationStrategy} from './src/router/path_location_strategy';
+import {Router, RootRouter} from './src/router/router';
 import {RouterOutlet} from './src/router/router_outlet';
 import {RouterLink} from './src/router/router_link';
+import {RouteRegistry, ROUTER_PRIMARY_COMPONENT} from './src/router/route_registry';
+import {Location} from './src/router/location';
+import {ApplicationRef, provide, OpaqueToken, Provider} from 'angular2/core';
 import {CONST_EXPR} from './src/facade/lang';
+import {BaseException} from 'angular2/src/facade/exceptions';
 
 /**
  * A list of directives. To use the router directives like {@link RouterOutlet} and
@@ -50,3 +56,63 @@ import {CONST_EXPR} from './src/facade/lang';
  * ```
  */
 export const ROUTER_DIRECTIVES: any[] = CONST_EXPR([RouterOutlet, RouterLink]);
+
+/**
+ * A list of {@link Provider}s. To use the router, you must add this to your application.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/iRUP8B5OUbxCWQ3AcIDm))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {
+ *   ROUTER_DIRECTIVES,
+ *   ROUTER_PROVIDERS,
+ *   RouteConfig
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ *  {...},
+ * ])
+ * class AppCmp {
+ *   // ...
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+export const ROUTER_PROVIDERS: any[] = CONST_EXPR([
+  RouteRegistry,
+  CONST_EXPR(new Provider(LocationStrategy, {useClass: PathLocationStrategy})),
+  PlatformLocation,
+  Location,
+  CONST_EXPR(new Provider(
+      Router,
+      {
+        useFactory: routerFactory,
+        deps: CONST_EXPR([RouteRegistry, Location, ROUTER_PRIMARY_COMPONENT, ApplicationRef])
+      })),
+  CONST_EXPR(new Provider(
+      ROUTER_PRIMARY_COMPONENT,
+      {useFactory: routerPrimaryComponentFactory, deps: CONST_EXPR([ApplicationRef])}))
+]);
+
+/**
+ * Use {@link ROUTER_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+export const ROUTER_BINDINGS = ROUTER_PROVIDERS;
+
+function routerFactory(registry, location, primaryComponent, appRef) {
+  var rootRouter = new RootRouter(registry, location, primaryComponent);
+  appRef.registerDisposeListener(() => rootRouter.dispose());
+  return rootRouter;
+}
+
+function routerPrimaryComponentFactory(app) {
+  if (app.componentTypes.length == 0) {
+    throw new BaseException("Bootstrap at least one component before injecting Router.");
+  }
+  return app.componentTypes[0];
+}

modules/angular2/src/common/directives/ng_for.ts

@@ -6,8 +6,7 @@ import {
   IterableDiffers,
   ViewContainerRef,
   TemplateRef,
-  EmbeddedViewRef,
-  TrackByFn
+  EmbeddedViewRef
 } from 'angular2/core';
 import {isPresent, isBlank} from 'angular2/src/facade/lang';
 
@@ -60,11 +59,10 @@ import {isPresent, isBlank} from 'angular2/src/facade/lang';
  * See a [live demo](http://plnkr.co/edit/KVuXxDp0qinGDyo307QW?p=preview) for a more detailed
  * example.
  */
-@Directive({selector: '[ngFor][ngForOf]', inputs: ['ngForTrackBy', 'ngForOf', 'ngForTemplate']})
+@Directive({selector: '[ngFor][ngForOf]', inputs: ['ngForOf', 'ngForTemplate']})
 export class NgFor implements DoCheck {
   /** @internal */
   _ngForOf: any;
-  _ngForTrackBy: TrackByFn;
   private _differ: IterableDiffer;
 
   constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef,
@@ -73,7 +71,7 @@ export class NgFor implements DoCheck {
   set ngForOf(value: any) {
     this._ngForOf = value;
     if (isBlank(this._differ) && isPresent(value)) {
-      this._differ = this._iterableDiffers.find(value).create(this._cdr, this._ngForTrackBy);
+      this._differ = this._iterableDiffers.find(value).create(this._cdr);
     }
   }
 
@@ -83,8 +81,6 @@ export class NgFor implements DoCheck {
     }
   }
 
-  set ngForTrackBy(value: TrackByFn) { this._ngForTrackBy = value; }
-
   ngDoCheck() {
     if (isPresent(this._differ)) {
       var changes = this._differ.diff(this._ngForOf);
@@ -117,11 +113,6 @@ export class NgFor implements DoCheck {
       var viewRef = <EmbeddedViewRef>this._viewContainer.get(i);
       viewRef.setLocal('last', i === ilen - 1);
     }
-
-    changes.forEachIdentityChange((record) => {
-      var viewRef = <EmbeddedViewRef>this._viewContainer.get(record.currentIndex);
-      viewRef.setLocal('\$implicit', record.item);
-    });
   }
 
   private _perViewChange(view, record) {

modules/angular2/src/common/directives/observable_list_diff.dart

@@ -57,7 +57,7 @@ class ObservableListDiff extends DefaultIterableDiffer {
 class ObservableListDiffFactory implements IterableDifferFactory {
   const ObservableListDiffFactory();
   bool supports(obj) => obj is ObservableList;
-  IterableDiffer create(ChangeDetectorRef cdRef, [Function trackByFn]) {
+  IterableDiffer create(ChangeDetectorRef cdRef) {
     return new ObservableListDiff(cdRef);
   }
 }

modules/angular2/src/common/forms.ts

@@ -31,7 +31,7 @@ export {
   NgSelectOption,
   SelectControlValueAccessor
 } from './forms/directives/select_control_value_accessor';
-export {FORM_DIRECTIVES, RadioButtonState} from './forms/directives';
+export {FORM_DIRECTIVES} from './forms/directives';
 export {NG_VALIDATORS, NG_ASYNC_VALIDATORS, Validators} from './forms/validators';
 export {
   RequiredValidator,
@@ -39,25 +39,4 @@ export {
   MaxLengthValidator,
   Validator
 } from './forms/directives/validators';
-export {FormBuilder} from './forms/form_builder';
-import {FormBuilder} from './forms/form_builder';
-import {RadioControlRegistry} from './forms/directives/radio_control_value_accessor';
-import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
-
-/**
- * Shorthand set of providers used for building Angular forms.
- *
- * ### Example
- *
- * ```typescript
- * bootstrap(MyApp, [FORM_PROVIDERS]);
- * ```
- */
-export const FORM_PROVIDERS: Type[] = CONST_EXPR([FormBuilder, RadioControlRegistry]);
-
-/**
- * See {@link FORM_PROVIDERS} instead.
- *
- * @deprecated
- */
-export const FORM_BINDINGS = FORM_PROVIDERS;
+export {FormBuilder, FORM_PROVIDERS, FORM_BINDINGS} from './forms/form_builder';

modules/angular2/src/common/forms/directives.ts

@@ -8,7 +8,6 @@ import {NgForm} from './directives/ng_form';
 import {DefaultValueAccessor} from './directives/default_value_accessor';
 import {CheckboxControlValueAccessor} from './directives/checkbox_value_accessor';
 import {NumberValueAccessor} from './directives/number_value_accessor';
-import {RadioControlValueAccessor} from './directives/radio_control_value_accessor';
 import {NgControlStatus} from './directives/ng_control_status';
 import {
   SelectControlValueAccessor,
@@ -24,10 +23,6 @@ export {NgFormModel} from './directives/ng_form_model';
 export {NgForm} from './directives/ng_form';
 export {DefaultValueAccessor} from './directives/default_value_accessor';
 export {CheckboxControlValueAccessor} from './directives/checkbox_value_accessor';
-export {
-  RadioControlValueAccessor,
-  RadioButtonState
-} from './directives/radio_control_value_accessor';
 export {NumberValueAccessor} from './directives/number_value_accessor';
 export {NgControlStatus} from './directives/ng_control_status';
 export {
@@ -68,7 +63,6 @@ export const FORM_DIRECTIVES: Type[] = CONST_EXPR([
   NumberValueAccessor,
   CheckboxControlValueAccessor,
   SelectControlValueAccessor,
-  RadioControlValueAccessor,
   NgControlStatus,
 
   RequiredValidator,

modules/angular2/src/common/forms/directives/checkbox_value_accessor.ts

@@ -18,7 +18,7 @@ const CHECKBOX_VALUE_ACCESSOR = CONST_EXPR(new Provider(
   selector:
       'input[type=checkbox][ngControl],input[type=checkbox][ngFormControl],input[type=checkbox][ngModel]',
   host: {'(change)': 'onChange($event.target.checked)', '(blur)': 'onTouched()'},
-  providers: [CHECKBOX_VALUE_ACCESSOR]
+  bindings: [CHECKBOX_VALUE_ACCESSOR]
 })
 export class CheckboxControlValueAccessor implements ControlValueAccessor {
   onChange = (_) => {};

modules/angular2/src/common/forms/directives/radio_control_value_accessor.ts

@@ -1,126 +0,0 @@
-import {
-  Directive,
-  ElementRef,
-  Renderer,
-  Self,
-  forwardRef,
-  Provider,
-  Attribute,
-  Input,
-  OnInit,
-  OnDestroy,
-  Injector,
-  Injectable
-} from 'angular2/core';
-import {
-  NG_VALUE_ACCESSOR,
-  ControlValueAccessor
-} from 'angular2/src/common/forms/directives/control_value_accessor';
-import {NgControl} from 'angular2/src/common/forms/directives/ng_control';
-import {CONST_EXPR, looseIdentical, isPresent} from 'angular2/src/facade/lang';
-import {ListWrapper} from 'angular2/src/facade/collection';
-
-const RADIO_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => RadioControlValueAccessor), multi: true}));
-
-
-/**
- * Internal class used by Angular to uncheck radio buttons with the matching name.
- */
-@Injectable()
-export class RadioControlRegistry {
-  private _accessors: any[] = [];
-
-  add(control: NgControl, accessor: RadioControlValueAccessor) {
-    this._accessors.push([control, accessor]);
-  }
-
-  remove(accessor: RadioControlValueAccessor) {
-    var indexToRemove = -1;
-    for (var i = 0; i < this._accessors.length; ++i) {
-      if (this._accessors[i][1] === accessor) {
-        indexToRemove = i;
-      }
-    }
-    ListWrapper.removeAt(this._accessors, indexToRemove);
-  }
-
-  select(accessor: RadioControlValueAccessor) {
-    this._accessors.forEach((c) => {
-      if (c[0].control.root === accessor._control.control.root && c[1] !== accessor) {
-        c[1].fireUncheck();
-      }
-    });
-  }
-}
-
-/**
- * The value provided by the forms API for radio buttons.
- */
-export class RadioButtonState {
-  constructor(public checked: boolean, public value: string) {}
-}
-
-
-/**
- * The accessor for writing a radio control value and listening to changes that is used by the
- * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
- *
- *  ### Example
- *  ```
- *  @Component({
- *    template: `
- *      <input type="radio" name="food" [(ngModel)]="foodChicken">
- *      <input type="radio" name="food" [(ngModel)]="foodFish">
- *    `
- *  })
- *  class FoodCmp {
- *    foodChicken = new RadioButtonState(true, "chicken");
- *    foodFish = new RadioButtonState(false, "fish");
- *  }
- *  ```
- */
-@Directive({
-  selector:
-      'input[type=radio][ngControl],input[type=radio][ngFormControl],input[type=radio][ngModel]',
-  host: {'(change)': 'onChange()', '(blur)': 'onTouched()'},
-  providers: [RADIO_VALUE_ACCESSOR]
-})
-export class RadioControlValueAccessor implements ControlValueAccessor,
-    OnDestroy, OnInit {
-  _state: RadioButtonState;
-  _control: NgControl;
-  @Input() name: string;
-  _fn: Function;
-  onChange = () => {};
-  onTouched = () => {};
-
-  constructor(private _renderer: Renderer, private _elementRef: ElementRef,
-              private _registry: RadioControlRegistry, private _injector: Injector) {}
-
-  ngOnInit(): void {
-    this._control = this._injector.get(NgControl);
-    this._registry.add(this._control, this);
-  }
-
-  ngOnDestroy(): void { this._registry.remove(this); }
-
-  writeValue(value: any): void {
-    this._state = value;
-    if (isPresent(value) && value.checked) {
-      this._renderer.setElementProperty(this._elementRef.nativeElement, 'checked', true);
-    }
-  }
-
-  registerOnChange(fn: (_: any) => {}): void {
-    this._fn = fn;
-    this.onChange = () => {
-      fn(new RadioButtonState(true, this._state.value));
-      this._registry.select(this);
-    };
-  }
-
-  fireUncheck(): void { this._fn(new RadioButtonState(false, this._state.value)); }
-
-  registerOnTouched(fn: () => {}): void { this.onTouched = fn; }
-}

modules/angular2/src/common/forms/directives/shared.ts

@@ -1,5 +1,5 @@
 import {ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
-import {isBlank, isPresent, looseIdentical, hasConstructor} from 'angular2/src/facade/lang';
+import {isBlank, isPresent, looseIdentical} from 'angular2/src/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
 
 import {ControlContainer} from './control_container';
@@ -13,7 +13,6 @@ import {DefaultValueAccessor} from './default_value_accessor';
 import {NumberValueAccessor} from './number_value_accessor';
 import {CheckboxControlValueAccessor} from './checkbox_value_accessor';
 import {SelectControlValueAccessor} from './select_control_value_accessor';
-import {RadioControlValueAccessor} from './radio_control_value_accessor';
 import {normalizeValidator} from './normalize_validator';
 
 
@@ -82,13 +81,11 @@ export function selectValueAccessor(dir: NgControl,
   var builtinAccessor;
   var customAccessor;
   valueAccessors.forEach(v => {
-    if (hasConstructor(v, DefaultValueAccessor)) {
+    if (v instanceof DefaultValueAccessor) {
       defaultAccessor = v;
 
-    } else if (hasConstructor(v, CheckboxControlValueAccessor) ||
-               hasConstructor(v, NumberValueAccessor) ||
-               hasConstructor(v, SelectControlValueAccessor) ||
-               hasConstructor(v, RadioControlValueAccessor)) {
+    } else if (v instanceof CheckboxControlValueAccessor || v instanceof NumberValueAccessor ||
+               v instanceof SelectControlValueAccessor) {
       if (isPresent(builtinAccessor))
         _throwError(dir, "More than one built-in value accessor matches");
       builtinAccessor = v;

modules/angular2/src/common/forms/form_builder.ts

@@ -105,4 +105,22 @@ export class FormBuilder {
       return this.control(controlConfig);
     }
   }
-}
+}
+
+/**
+ * Shorthand set of providers used for building Angular forms.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * bootstrap(MyApp, [FORM_PROVIDERS]);
+ * ```
+ */
+export const FORM_PROVIDERS: Type[] = CONST_EXPR([FormBuilder]);
+
+/**
+ * See {@link FORM_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+export const FORM_BINDINGS = FORM_PROVIDERS;

modules/angular2/src/common/forms/model.ts

@@ -208,16 +208,6 @@ export abstract class AbstractControl {
     return isPresent(this.getError(errorCode, path));
   }
 
-  get root(): AbstractControl {
-    let x: AbstractControl = this;
-
-    while (isPresent(x._parent)) {
-      x = x._parent;
-    }
-
-    return x;
-  }
-
   /** @internal */
   _updateControlsErrors(): void {
     this._status = this._calculateStatus();

modules/angular2/src/common/forms/validators.ts

@@ -1,4 +1,4 @@
-import {isBlank, isPresent, CONST_EXPR, isString} from 'angular2/src/facade/lang';
+import {isBlank, isPresent, CONST_EXPR} from 'angular2/src/facade/lang';
 import {PromiseWrapper} from 'angular2/src/facade/promise';
 import {ObservableWrapper} from 'angular2/src/facade/async';
 import {ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
@@ -44,9 +44,7 @@ export class Validators {
    * Validator that requires controls to have a non-empty value.
    */
   static required(control: modelModule.Control): {[key: string]: boolean} {
-    return isBlank(control.value) || (isString(control.value) && control.value == "") ?
-               {"required": true} :
-               null;
+    return isBlank(control.value) || control.value == "" ? {"required": true} : null;
   }
 
   /**

modules/angular2/src/common/pipes/async_pipe.ts

@@ -81,7 +81,6 @@ export class AsyncPipe implements PipeTransform, OnDestroy {
       if (isPresent(obj)) {
         this._subscribe(obj);
       }
-      this._latestReturnedValue = this._latestValue;
       return this._latestValue;
     }
 

modules/angular2/src/compiler/template_parser.ts

@@ -433,9 +433,8 @@ class TemplateParseVisitor implements HtmlAstVisitor {
     var parts = splitAtColon(name, [null, name]);
     var target = parts[0];
     var eventName = parts[1];
-    var ast = this._parseAction(expression, sourceSpan);
-    targetMatchableAttrs.push([name, ast.source]);
-    targetEvents.push(new BoundEventAst(eventName, target, ast, sourceSpan));
+    targetEvents.push(new BoundEventAst(eventName, target,
+                                        this._parseAction(expression, sourceSpan), sourceSpan));
     // Don't detect directives for event names for now,
     // so don't add the event name to the matchableAttrs
   }

modules/angular2/src/core/application_common_providers.ts

@@ -15,6 +15,7 @@ import {ResolvedMetadataCache} from 'angular2/src/core/linker/resolved_metadata_
 import {AppViewManager} from './linker/view_manager';
 import {AppViewManager_} from "./linker/view_manager";
 import {ViewResolver} from './linker/view_resolver';
+import {AppViewListener} from './linker/view_listener';
 import {DirectiveResolver} from './linker/directive_resolver';
 import {PipeResolver} from './linker/pipe_resolver';
 import {Compiler} from './linker/compiler';
@@ -31,6 +32,7 @@ export const APPLICATION_COMMON_PROVIDERS: Array<Type | Provider | any[]> = CONS
   APP_ID_RANDOM_PROVIDER,
   ResolvedMetadataCache,
   new Provider(AppViewManager, {useClass: AppViewManager_}),
+  AppViewListener,
   ViewResolver,
   new Provider(IterableDiffers, {useValue: defaultIterableDiffers}),
   new Provider(KeyValueDiffers, {useValue: defaultKeyValueDiffers}),

modules/angular2/src/core/application_ref.ts

@@ -456,10 +456,11 @@ export class ApplicationRef_ extends ApplicationRef {
     });
     return completer.promise.then(_ => {
       let c = this._injector.get(Console);
-      if (assertionsEnabled()) {
-        c.log(
-            "Angular 2 is running in the development mode. Call enableProdMode() to enable the production mode.");
-      }
+      let modeDescription =
+          assertionsEnabled() ?
+              "in the development mode. Call enableProdMode() to enable the production mode." :
+              "in the production mode. Call enableDevMode() to enable the development mode.";
+      c.log(`Angular 2 is running ${modeDescription}`);
       return _;
     });
   }

modules/angular2/src/core/change_detection.ts

@@ -20,6 +20,5 @@ export {
   IterableDifferFactory,
   KeyValueDiffers,
   KeyValueDiffer,
-  KeyValueDifferFactory,
-  TrackByFn
+  KeyValueDifferFactory
 } from './change_detection/change_detection';

modules/angular2/src/core/change_detection/abstract_change_detector.ts

@@ -73,7 +73,7 @@ export class AbstractChangeDetector<T> implements ChangeDetector {
 
   handleEvent(eventName: string, elIndex: number, event: any): boolean {
     if (!this.hydrated()) {
-      this.throwDehydratedError(`${this.id} -> ${eventName}`);
+      this.throwDehydratedError();
     }
     try {
       var locals = new Map<string, any>();
@@ -130,7 +130,7 @@ export class AbstractChangeDetector<T> implements ChangeDetector {
   // facilitate error reporting.
   detectChangesInRecords(throwOnChange: boolean): void {
     if (!this.hydrated()) {
-      this.throwDehydratedError(this.id);
+      this.throwDehydratedError();
     }
     try {
       this.detectChangesInRecordsInternal(throwOnChange);
@@ -362,7 +362,7 @@ export class AbstractChangeDetector<T> implements ChangeDetector {
                                                               oldValue, newValue, null);
   }
 
-  throwDehydratedError(detail: string): void { throw new DehydratedException(detail); }
+  throwDehydratedError(): void { throw new DehydratedException(); }
 
   private _currentBinding(): BindingTarget {
     return this.bindingTargets[this.propertyBindingIndex];

modules/angular2/src/core/change_detection/change_detection.ts

@@ -1,4 +1,4 @@
-import {IterableDiffers, IterableDifferFactory, TrackByFn} from './differs/iterable_differs';
+import {IterableDiffers, IterableDifferFactory} from './differs/iterable_differs';
 import {DefaultIterableDifferFactory} from './differs/default_iterable_differ';
 import {KeyValueDiffers, KeyValueDifferFactory} from './differs/keyvalue_differs';
 import {DefaultKeyValueDifferFactory} from './differs/default_keyvalue_differ';
@@ -37,12 +37,7 @@ export {BindingRecord, BindingTarget} from './binding_record';
 export {DirectiveIndex, DirectiveRecord} from './directive_record';
 export {DynamicChangeDetector} from './dynamic_change_detector';
 export {ChangeDetectorRef} from './change_detector_ref';
-export {
-  IterableDiffers,
-  IterableDiffer,
-  IterableDifferFactory,
-  TrackByFn
-} from './differs/iterable_differs';
+export {IterableDiffers, IterableDiffer, IterableDifferFactory} from './differs/iterable_differs';
 export {KeyValueDiffers, KeyValueDiffer, KeyValueDifferFactory} from './differs/keyvalue_differs';
 export {PipeTransform} from './pipe_transform';
 export {WrappedValue, SimpleChange} from './change_detection_util';

modules/angular2/src/core/change_detection/change_detection_jit_generator.ts

@@ -350,7 +350,6 @@ export class ChangeDetectorJITGenerator {
     var condition = `!${pipe}.pure || (${contexOrArgCheck.join(" || ")})`;
 
     var check = `
-      ${this._genThrowOnChangeCheck(oldValue, newValue)}
       if (${this.changeDetectionUtilVarName}.looseNotIdentical(${oldValue}, ${newValue})) {
         ${newValue} = ${this.changeDetectionUtilVarName}.unwrapValue(${newValue})
         ${this._genChangeMarker(r)}
@@ -378,7 +377,6 @@ export class ChangeDetectorJITGenerator {
     `;
 
     var check = `
-      ${this._genThrowOnChangeCheck(oldValue, newValue)}
       if (${this.changeDetectionUtilVarName}.looseNotIdentical(${oldValue}, ${newValue})) {
         ${this._genChangeMarker(r)}
         ${this._genUpdateDirectiveOrElement(r)}
@@ -411,6 +409,7 @@ export class ChangeDetectorJITGenerator {
     if (!r.lastInBinding) return "";
 
     var newValue = this._names.getLocalName(r.selfIndex);
+    var oldValue = this._names.getFieldName(r.selfIndex);
     var notifyDebug = this.genConfig.logBindingUpdate ? `this.logBindingUpdate(${newValue});` : "";
 
     var br = r.bindingRecord;
@@ -418,12 +417,14 @@ export class ChangeDetectorJITGenerator {
       var directiveProperty =
           `${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.${br.target.name}`;
       return `
+        ${this._genThrowOnChangeCheck(oldValue, newValue)}
         ${directiveProperty} = ${newValue};
         ${notifyDebug}
         ${IS_CHANGED_LOCAL} = true;
       `;
     } else {
       return `
+        ${this._genThrowOnChangeCheck(oldValue, newValue)}
         this.notifyDispatcher(${newValue});
         ${notifyDebug}
       `;
@@ -434,7 +435,7 @@ export class ChangeDetectorJITGenerator {
   _genThrowOnChangeCheck(oldValue: string, newValue: string): string {
     if (assertionsEnabled()) {
       return `
-        if (throwOnChange && !${this.changeDetectionUtilVarName}.devModeEqual(${oldValue}, ${newValue})) {
+        if(throwOnChange) {
           this.throwOnChangeError(${oldValue}, ${newValue});
         }
         `;

modules/angular2/src/core/change_detection/change_detection_util.ts

@@ -4,17 +4,10 @@ import {
   isBlank,
   Type,
   StringWrapper,
-  looseIdentical,
-  isPrimitive
+  looseIdentical
 } from 'angular2/src/facade/lang';
 import {BaseException} from 'angular2/src/facade/exceptions';
-import {
-  ListWrapper,
-  MapWrapper,
-  StringMapWrapper,
-  isListLikeIterable,
-  areIterablesEqual
-} from 'angular2/src/facade/collection';
+import {ListWrapper, MapWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
 import {ProtoRecord} from './proto_record';
 import {ChangeDetectionStrategy, isDefaultChangeDetectionStrategy} from './constants';
 import {implementsOnDestroy} from './pipe_lifecycle_reflector';
@@ -221,17 +214,4 @@ export class ChangeDetectionUtil {
   }
 
   static looseNotIdentical(a: any, b: any): boolean { return !looseIdentical(a, b); }
-
-  static devModeEqual(a: any, b: any): boolean {
-    if (isListLikeIterable(a) && isListLikeIterable(b)) {
-      return areIterablesEqual(a, b, ChangeDetectionUtil.devModeEqual);
-
-    } else if (!isListLikeIterable(a) && !isPrimitive(a) && !isListLikeIterable(b) &&
-               !isPrimitive(b)) {
-      return true;
-
-    } else {
-      return looseIdentical(a, b);
-    }
-  }
 }

modules/angular2/src/core/change_detection/differs/default_iterable_differ.ts

@@ -1,6 +1,11 @@
 import {CONST} from 'angular2/src/facade/lang';
 import {BaseException} from 'angular2/src/facade/exceptions';
-import {isListLikeIterable, iterateListLike, ListWrapper} from 'angular2/src/facade/collection';
+import {
+  isListLikeIterable,
+  iterateListLike,
+  ListWrapper,
+  MapWrapper
+} from 'angular2/src/facade/collection';
 
 import {
   isBlank,
@@ -12,21 +17,17 @@ import {
 } from 'angular2/src/facade/lang';
 
 import {ChangeDetectorRef} from '../change_detector_ref';
-import {IterableDiffer, IterableDifferFactory, TrackByFn} from '../differs/iterable_differs';
+import {IterableDiffer, IterableDifferFactory} from '../differs/iterable_differs';
 
 @CONST()
 export class DefaultIterableDifferFactory implements IterableDifferFactory {
   supports(obj: Object): boolean { return isListLikeIterable(obj); }
-  create(cdRef: ChangeDetectorRef, trackByFn?: TrackByFn): DefaultIterableDiffer {
-    return new DefaultIterableDiffer(trackByFn);
-  }
+  create(cdRef: ChangeDetectorRef): DefaultIterableDiffer { return new DefaultIterableDiffer(); }
 }
 
-var trackByIdentity = (index: number, item: any) => item;
-
 export class DefaultIterableDiffer implements IterableDiffer {
-  private _length: number = null;
   private _collection = null;
+  private _length: number = null;
   // Keeps track of the used records at any point in time (during & across `_check()` calls)
   private _linkedRecords: _DuplicateMap = null;
   // Keeps track of the removed records at any point in time during `_check()` calls.
@@ -40,13 +41,6 @@ export class DefaultIterableDiffer implements IterableDiffer {
   private _movesTail: CollectionChangeRecord = null;
   private _removalsHead: CollectionChangeRecord = null;
   private _removalsTail: CollectionChangeRecord = null;
-  // Keeps track of records where custom track by is the same, but item identity has changed
-  private _identityChangesHead: CollectionChangeRecord = null;
-  private _identityChangesTail: CollectionChangeRecord = null;
-
-  constructor(private _trackByFn?: TrackByFn) {
-    this._trackByFn = isPresent(this._trackByFn) ? this._trackByFn : trackByIdentity;
-  }
 
   get collection() { return this._collection; }
 
@@ -87,13 +81,6 @@ export class DefaultIterableDiffer implements IterableDiffer {
     }
   }
 
-  forEachIdentityChange(fn: Function) {
-    var record: CollectionChangeRecord;
-    for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
-      fn(record);
-    }
-  }
-
   diff(collection: any): DefaultIterableDiffer {
     if (isBlank(collection)) collection = [];
     if (!isListLikeIterable(collection)) {
@@ -117,40 +104,31 @@ export class DefaultIterableDiffer implements IterableDiffer {
     var mayBeDirty: boolean = false;
     var index: number;
     var item;
-    var itemTrackBy;
+
     if (isArray(collection)) {
       var list = collection;
       this._length = collection.length;
 
       for (index = 0; index < this._length; index++) {
         item = list[index];
-        itemTrackBy = this._trackByFn(index, item);
-        if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {
-          record = this._mismatch(record, item, itemTrackBy, index);
+        if (record === null || !looseIdentical(record.item, item)) {
+          record = this._mismatch(record, item, index);
           mayBeDirty = true;
-        } else {
-          if (mayBeDirty) {
-            // TODO(misko): can we limit this to duplicates only?
-            record = this._verifyReinsertion(record, item, itemTrackBy, index);
-          }
-          if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+        } else if (mayBeDirty) {
+          // TODO(misko): can we limit this to duplicates only?
+          record = this._verifyReinsertion(record, item, index);
         }
-
         record = record._next;
       }
     } else {
       index = 0;
       iterateListLike(collection, (item) => {
-        itemTrackBy = this._trackByFn(index, item);
-        if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {
-          record = this._mismatch(record, item, itemTrackBy, index);
+        if (record === null || !looseIdentical(record.item, item)) {
+          record = this._mismatch(record, item, index);
           mayBeDirty = true;
-        } else {
-          if (mayBeDirty) {
-            // TODO(misko): can we limit this to duplicates only?
-            record = this._verifyReinsertion(record, item, itemTrackBy, index);
-          }
-          if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
+        } else if (mayBeDirty) {
+          // TODO(misko): can we limit this to duplicates only?
+          record = this._verifyReinsertion(record, item, index);
         }
         record = record._next;
         index++;
@@ -163,12 +141,9 @@ export class DefaultIterableDiffer implements IterableDiffer {
     return this.isDirty;
   }
 
-  /* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
-   * changes.
-   */
+  // CollectionChanges is considered dirty if it has any additions, moves or removals.
   get isDirty(): boolean {
-    return this._additionsHead !== null || this._movesHead !== null ||
-           this._removalsHead !== null || this._identityChangesHead !== null;
+    return this._additionsHead !== null || this._movesHead !== null || this._removalsHead !== null;
   }
 
   /**
@@ -199,7 +174,6 @@ export class DefaultIterableDiffer implements IterableDiffer {
       }
       this._movesHead = this._movesTail = null;
       this._removalsHead = this._removalsTail = null;
-      this._identityChangesHead = this._identityChangesTail = null;
 
       // todo(vicb) when assert gets supported
       // assert(!this.isDirty);
@@ -216,8 +190,7 @@ export class DefaultIterableDiffer implements IterableDiffer {
    *
    * @internal
    */
-  _mismatch(record: CollectionChangeRecord, item: any, itemTrackBy: any,
-            index: number): CollectionChangeRecord {
+  _mismatch(record: CollectionChangeRecord, item, index: number): CollectionChangeRecord {
     // The previous record after which we will append the current one.
     var previousRecord: CollectionChangeRecord;
 
@@ -230,26 +203,19 @@ export class DefaultIterableDiffer implements IterableDiffer {
     }
 
     // Attempt to see if we have seen the item before.
-    record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);
+    record = this._linkedRecords === null ? null : this._linkedRecords.get(item, index);
     if (record !== null) {
       // We have seen this before, we need to move it forward in the collection.
-      // But first we need to check if identity changed, so we can update in view if necessary
-      if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
-
       this._moveAfter(record, previousRecord, index);
     } else {
       // Never seen it, check evicted list.
-      record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
+      record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item);
       if (record !== null) {
         // It is an item which we have evicted earlier: reinsert it back into the list.
-        // But first we need to check if identity changed, so we can update in view if necessary
-        if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item);
-
         this._reinsertAfter(record, previousRecord, index);
       } else {
         // It is a new item: add it.
-        record =
-            this._addAfter(new CollectionChangeRecord(item, itemTrackBy), previousRecord, index);
+        record = this._addAfter(new CollectionChangeRecord(item), previousRecord, index);
       }
     }
     return record;
@@ -282,10 +248,9 @@ export class DefaultIterableDiffer implements IterableDiffer {
    *
    * @internal
    */
-  _verifyReinsertion(record: CollectionChangeRecord, item: any, itemTrackBy: any,
-                     index: number): CollectionChangeRecord {
+  _verifyReinsertion(record: CollectionChangeRecord, item, index: number): CollectionChangeRecord {
     var reinsertRecord: CollectionChangeRecord =
-        this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy);
+        this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item);
     if (reinsertRecord !== null) {
       record = this._reinsertAfter(reinsertRecord, record._prev, index);
     } else if (record.currentIndex != index) {
@@ -491,41 +456,36 @@ export class DefaultIterableDiffer implements IterableDiffer {
     return record;
   }
 
-  /** @internal */
-  _addIdentityChange(record: CollectionChangeRecord, item: any) {
-    record.item = item;
-    if (this._identityChangesTail === null) {
-      this._identityChangesTail = this._identityChangesHead = record;
-    } else {
-      this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
-    }
-    return record;
-  }
-
-
   toString(): string {
+    var record: CollectionChangeRecord;
+
     var list = [];
-    this.forEachItem((record) => list.push(record));
+    for (record = this._itHead; record !== null; record = record._next) {
+      list.push(record);
+    }
 
     var previous = [];
-    this.forEachPreviousItem((record) => previous.push(record));
+    for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
+      previous.push(record);
+    }
 
     var additions = [];
-    this.forEachAddedItem((record) => additions.push(record));
-
+    for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+      additions.push(record);
+    }
     var moves = [];
-    this.forEachMovedItem((record) => moves.push(record));
+    for (record = this._movesHead; record !== null; record = record._nextMoved) {
+      moves.push(record);
+    }
 
     var removals = [];
-    this.forEachRemovedItem((record) => removals.push(record));
-
-    var identityChanges = [];
-    this.forEachIdentityChange((record) => identityChanges.push(record));
+    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+      removals.push(record);
+    }
 
     return "collection: " + list.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" +
            "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" +
-           "removals: " + removals.join(', ') + "\n" + "identityChanges: " +
-           identityChanges.join(', ') + "\n";
+           "removals: " + removals.join(', ') + "\n";
   }
 }
 
@@ -551,11 +511,8 @@ export class CollectionChangeRecord {
   _nextAdded: CollectionChangeRecord = null;
   /** @internal */
   _nextMoved: CollectionChangeRecord = null;
-  /** @internal */
-  _nextIdentityChange: CollectionChangeRecord = null;
 
-
-  constructor(public item: any, public trackById: any) {}
+  constructor(public item: any) {}
 
   toString(): string {
     return this.previousIndex === this.currentIndex ?
@@ -593,13 +550,13 @@ class _DuplicateItemRecordList {
     }
   }
 
-  // Returns a CollectionChangeRecord having CollectionChangeRecord.trackById == trackById and
+  // Returns a CollectionChangeRecord having CollectionChangeRecord.item == item and
   // CollectionChangeRecord.currentIndex >= afterIndex
-  get(trackById: any, afterIndex: number): CollectionChangeRecord {
+  get(item: any, afterIndex: number): CollectionChangeRecord {
     var record: CollectionChangeRecord;
     for (record = this._head; record !== null; record = record._nextDup) {
       if ((afterIndex === null || afterIndex < record.currentIndex) &&
-          looseIdentical(record.trackById, trackById)) {
+          looseIdentical(record.item, item)) {
         return record;
       }
     }
@@ -642,7 +599,7 @@ class _DuplicateMap {
 
   put(record: CollectionChangeRecord) {
     // todo(vicb) handle corner cases
-    var key = getMapKey(record.trackById);
+    var key = getMapKey(record.item);
 
     var duplicates = this.map.get(key);
     if (!isPresent(duplicates)) {
@@ -653,17 +610,17 @@ class _DuplicateMap {
   }
 
   /**
-   * Retrieve the `value` using key. Because the CollectionChangeRecord value may be one which we
+   * Retrieve the `value` using key. Because the CollectionChangeRecord value maybe one which we
    * have already iterated over, we use the afterIndex to pretend it is not there.
    *
    * Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
    * have any more `a`s needs to return the last `a` not the first or second.
    */
-  get(trackById: any, afterIndex: number = null): CollectionChangeRecord {
-    var key = getMapKey(trackById);
+  get(value: any, afterIndex: number = null): CollectionChangeRecord {
+    var key = getMapKey(value);
 
     var recordList = this.map.get(key);
-    return isBlank(recordList) ? null : recordList.get(trackById, afterIndex);
+    return isBlank(recordList) ? null : recordList.get(value, afterIndex);
   }
 
   /**
@@ -672,7 +629,7 @@ class _DuplicateMap {
    * The list of duplicates also is removed from the map if it gets empty.
    */
   remove(record: CollectionChangeRecord): CollectionChangeRecord {
-    var key = getMapKey(record.trackById);
+    var key = getMapKey(record.item);
     // todo(vicb)
     // assert(this.map.containsKey(key));
     var recordList: _DuplicateItemRecordList = this.map.get(key);

modules/angular2/src/core/change_detection/differs/iterable_differs.ts

@@ -13,19 +13,12 @@ export interface IterableDiffer {
   onDestroy();
 }
 
-/**
-  * An optional function passed into {@link NgFor} that defines how to track
-  * items in an iterable (e.g. by index or id)
- */
-export interface TrackByFn { (index: number, item: any): any; }
-
-
 /**
  * Provides a factory for {@link IterableDiffer}.
  */
 export interface IterableDifferFactory {
   supports(objects: any): boolean;
-  create(cdRef: ChangeDetectorRef, trackByFn?: TrackByFn): IterableDiffer;
+  create(cdRef: ChangeDetectorRef): IterableDiffer;
 }
 
 /**

modules/angular2/src/core/change_detection/dynamic_change_detector.ts

@@ -304,10 +304,7 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
 
     if (proto.shouldBeChecked()) {
       var prevValue = this._readSelf(proto, values);
-      var detectedChange = throwOnChange ?
-                               !ChangeDetectionUtil.devModeEqual(prevValue, currValue) :
-                               ChangeDetectionUtil.looseNotIdentical(prevValue, currValue);
-      if (detectedChange) {
+      if (ChangeDetectionUtil.looseNotIdentical(prevValue, currValue)) {
         if (proto.lastInBinding) {
           var change = ChangeDetectionUtil.simpleChange(prevValue, currValue);
           if (throwOnChange) this.throwOnChangeError(prevValue, currValue);
@@ -408,10 +405,7 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
 
       if (proto.shouldBeChecked()) {
         var prevValue = this._readSelf(proto, values);
-        var detectedChange = throwOnChange ?
-                                 !ChangeDetectionUtil.devModeEqual(prevValue, currValue) :
-                                 ChangeDetectionUtil.looseNotIdentical(prevValue, currValue);
-        if (detectedChange) {
+        if (ChangeDetectionUtil.looseNotIdentical(prevValue, currValue)) {
           currValue = ChangeDetectionUtil.unwrapValue(currValue);
 
           if (proto.lastInBinding) {

modules/angular2/src/core/change_detection/exceptions.ts

@@ -91,7 +91,7 @@ export class ChangeDetectionError extends WrappedException {
  * This is an internal Angular error.
  */
 export class DehydratedException extends BaseException {
-  constructor(details: string) { super(`Attempt to use a dehydrated detector: ${details}`); }
+  constructor() { super('Attempt to use a dehydrated detector.'); }
 }
 
 /**

modules/angular2/src/core/change_detection/parser/lexer.ts

@@ -248,12 +248,15 @@ class _Scanner {
   }
 
   scanCharacter(start: number, code: number): Token {
+    assert(this.peek == code);
     this.advance();
     return newCharacterToken(start, code);
   }
 
 
   scanOperator(start: number, str: string): Token {
+    assert(this.peek == StringWrapper.charCodeAt(str, 0));
+    assert(SetWrapper.has(OPERATORS, str));
     this.advance();
     return newOperatorToken(start, str);
   }
@@ -271,6 +274,7 @@ class _Scanner {
    */
   scanComplexOperator(start: number, one: string, twoCode: number, two: string, threeCode?: number,
                       three?: string): Token {
+    assert(this.peek == StringWrapper.charCodeAt(one, 0));
     this.advance();
     var str: string = one;
     if (this.peek == twoCode) {
@@ -281,10 +285,12 @@ class _Scanner {
       this.advance();
       str += three;
     }
+    assert(SetWrapper.has(OPERATORS, str));
     return newOperatorToken(start, str);
   }
 
   scanIdentifier(): Token {
+    assert(isIdentifierStart(this.peek));
     var start: number = this.index;
     this.advance();
     while (isIdentifierPart(this.peek)) this.advance();
@@ -297,6 +303,7 @@ class _Scanner {
   }
 
   scanNumber(start: number): Token {
+    assert(isDigit(this.peek));
     var simple: boolean = (this.index === start);
     this.advance();  // Skip initial digit.
     while (true) {
@@ -322,6 +329,7 @@ class _Scanner {
   }
 
   scanString(): Token {
+    assert(this.peek == $SQ || this.peek == $DQ);
     var start: number = this.index;
     var quote: number = this.peek;
     this.advance();  // Skip initial quote.

modules/angular2/src/core/change_detection/parser/parser.ts

@@ -49,7 +49,7 @@ import {
 
 var _implicitReceiver = new ImplicitReceiver();
 // TODO(tbosch): Cannot make this const/final right now because of the transpiler...
-var INTERPOLATION_REGEXP = /\{\{([\s\S]*?)\}\}/g;
+var INTERPOLATION_REGEXP = /\{\{(.*?)\}\}/g;
 
 class ParseException extends BaseException {
   constructor(message: string, input: string, errLocation: string, ctxLocation?: any) {

modules/angular2/src/core/debug/debug_element.ts

@@ -0,0 +1,248 @@
+import {Type, isPresent, isBlank} from 'angular2/src/facade/lang';
+import {ListWrapper, MapWrapper, Predicate} from 'angular2/src/facade/collection';
+import {unimplemented} from 'angular2/src/facade/exceptions';
+
+import {AppElement} from 'angular2/src/core/linker/element';
+import {AppView} from 'angular2/src/core/linker/view';
+import {ElementRef, ElementRef_} from 'angular2/src/core/linker/element_ref';
+
+/**
+ * A DebugElement contains information from the Angular compiler about an
+ * element and provides access to the corresponding ElementInjector and
+ * underlying DOM Element, as well as a way to query for children.
+ *
+ * A DebugElement can be obtained from a {@link ComponentFixture} or from an
+ * {@link ElementRef} via {@link inspectElement}.
+ */
+export abstract class DebugElement {
+  /**
+   * Return the instance of the component associated with this element, if any.
+   */
+  get componentInstance(): any { return unimplemented(); };
+
+  /**
+   * Return the native HTML element for this DebugElement.
+   */
+  get nativeElement(): any { return unimplemented(); };
+
+  /**
+   * Return an Angular {@link ElementRef} for this element.
+   */
+  get elementRef(): ElementRef { return unimplemented(); };
+
+  /**
+   * Get the directive active for this element with the given index, if any.
+   */
+  abstract getDirectiveInstance(directiveIndex: number): any;
+
+  /**
+   * Get child DebugElements from within the Light DOM.
+   *
+   * @return {DebugElement[]}
+   */
+  get children(): DebugElement[] { return unimplemented(); };
+
+  /**
+   * Get the root DebugElement children of a component. Returns an empty
+   * list if the current DebugElement is not a component root.
+   *
+   * @return {DebugElement[]}
+   */
+  get componentViewChildren(): DebugElement[] { return unimplemented(); };
+
+  /**
+   * Simulate an event from this element as if the user had caused
+   * this event to fire from the page.
+   */
+  abstract triggerEventHandler(eventName: string, eventObj: Event): void;
+
+  /**
+   * Check whether the element has a directive with the given type.
+   */
+  abstract hasDirective(type: Type): boolean;
+
+  /**
+   * Inject the given type from the element injector.
+   */
+  abstract inject(type: Type): any;
+
+
+  /**
+   * Read a local variable from the element (e.g. one defined with `#variable`).
+   */
+  abstract getLocal(name: string): any;
+
+  /**
+   * Return the first descendant TestElement matching the given predicate
+   * and scope.
+   *
+   * @param {Function: boolean} predicate
+   * @param {Scope} scope
+   *
+   * @return {DebugElement}
+   */
+  query(predicate: Predicate<DebugElement>, scope: Function = Scope.all): DebugElement {
+    var results = this.queryAll(predicate, scope);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  /**
+   * Return descendant TestElememts matching the given predicate
+   * and scope.
+   *
+   * @param {Function: boolean} predicate
+   * @param {Scope} scope
+   *
+   * @return {DebugElement[]}
+   */
+  queryAll(predicate: Predicate<DebugElement>, scope: Function = Scope.all): DebugElement[] {
+    var elementsInScope: any[] = scope(this);
+
+    return elementsInScope.filter(predicate);
+  }
+}
+
+export class DebugElement_ extends DebugElement {
+  constructor(private _appElement: AppElement) { super(); }
+
+  get componentInstance(): any {
+    if (!isPresent(this._appElement)) {
+      return null;
+    }
+    return this._appElement.getComponent();
+  }
+
+  get nativeElement(): any { return this.elementRef.nativeElement; }
+
+  get elementRef(): ElementRef { return this._appElement.ref; }
+
+  getDirectiveInstance(directiveIndex: number): any {
+    return this._appElement.getDirectiveAtIndex(directiveIndex);
+  }
+
+  get children(): DebugElement[] {
+    return this._getChildElements(this._appElement.parentView, this._appElement);
+  }
+
+  get componentViewChildren(): DebugElement[] {
+    if (!isPresent(this._appElement.componentView)) {
+      // The current element is not a component.
+      return [];
+    }
+
+    return this._getChildElements(this._appElement.componentView, null);
+  }
+
+  triggerEventHandler(eventName: string, eventObj: Event): void {
+    this._appElement.parentView.triggerEventHandlers(eventName, eventObj,
+                                                     this._appElement.proto.index);
+  }
+
+  hasDirective(type: Type): boolean {
+    if (!isPresent(this._appElement)) {
+      return false;
+    }
+    return this._appElement.hasDirective(type);
+  }
+
+  inject(type: Type): any {
+    if (!isPresent(this._appElement)) {
+      return null;
+    }
+    return this._appElement.get(type);
+  }
+
+  getLocal(name: string): any { return this._appElement.parentView.locals.get(name); }
+
+  /** @internal */
+  _getChildElements(view: AppView, parentAppElement: AppElement): DebugElement[] {
+    var els = [];
+    for (var i = 0; i < view.appElements.length; ++i) {
+      var appEl = view.appElements[i];
+      if (appEl.parent == parentAppElement) {
+        els.push(new DebugElement_(appEl));
+
+        var views = appEl.nestedViews;
+        if (isPresent(views)) {
+          views.forEach(
+              (nextView) => { els = els.concat(this._getChildElements(nextView, null)); });
+        }
+      }
+    }
+    return els;
+  }
+}
+
+/**
+ * Returns a {@link DebugElement} for an {@link ElementRef}.
+ *
+ * @param {ElementRef}: elementRef
+ * @return {DebugElement}
+ */
+export function inspectElement(elementRef: ElementRef): DebugElement {
+  return new DebugElement_((<ElementRef_>elementRef).internalElement);
+}
+
+/**
+ * Maps an array of {@link DebugElement}s to an array of native DOM elements.
+ */
+export function asNativeElements(arr: DebugElement[]): any[] {
+  return arr.map((debugEl) => debugEl.nativeElement);
+}
+
+/**
+ * Set of scope functions used with {@link DebugElement}'s query functionality.
+ */
+export class Scope {
+  /**
+   * Scope queries to both the light dom and view of an element and its
+   * children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_all'}
+   */
+  static all(debugElement: DebugElement): DebugElement[] {
+    var scope = [];
+    scope.push(debugElement);
+
+    debugElement.children.forEach(child => scope = scope.concat(Scope.all(child)));
+
+    debugElement.componentViewChildren.forEach(child => scope = scope.concat(Scope.all(child)));
+
+    return scope;
+  }
+
+  /**
+   * Scope queries to the light dom of an element and its children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_light'}
+   */
+  static light(debugElement: DebugElement): DebugElement[] {
+    var scope = [];
+    debugElement.children.forEach(child => {
+      scope.push(child);
+      scope = scope.concat(Scope.light(child));
+    });
+    return scope;
+  }
+
+  /**
+   * Scope queries to the view of an element of its children.
+   *
+   * ## Example
+   *
+   * {@example core/debug/ts/debug_element/debug_element.ts region='scope_view'}
+   */
+  static view(debugElement: DebugElement): DebugElement[] {
+    var scope = [];
+
+    debugElement.componentViewChildren.forEach(child => {
+      scope.push(child);
+      scope = scope.concat(Scope.light(child));
+    });
+    return scope;
+  }
+}

modules/angular2/src/core/debug/debug_node.ts

@@ -1,171 +0,0 @@
-import {isPresent} from 'angular2/src/facade/lang';
-import {Predicate} from 'angular2/src/facade/collection';
-import {Injector} from 'angular2/src/core/di';
-import {ListWrapper, MapWrapper} from 'angular2/src/facade/collection';
-import {RenderDebugInfo} from 'angular2/src/core/render/api';
-
-export class EventListener { constructor(public name: string, public callback: Function){}; }
-
-export class DebugNode {
-  nativeNode: any;
-  listeners: EventListener[];
-  parent: DebugElement;
-  providerTokens: any[];
-  locals: Map<string, any>;
-  injector: Injector;
-  componentInstance: any;
-
-  constructor(nativeNode: any, parent: DebugNode) {
-    this.nativeNode = nativeNode;
-    if (isPresent(parent) && parent instanceof DebugElement) {
-      parent.addChild(this);
-    } else {
-      this.parent = null;
-    }
-    this.listeners = [];
-    this.providerTokens = [];
-  }
-
-  setDebugInfo(info: RenderDebugInfo) {
-    this.injector = info.injector;
-    this.providerTokens = info.providerTokens;
-    this.locals = info.locals;
-    this.componentInstance = info.component;
-  }
-
-  inject(token: any): any { return this.injector.get(token); }
-
-  getLocal(name: string): any { return this.locals.get(name); }
-}
-
-export class DebugElement extends DebugNode {
-  name: string;
-  properties: Map<string, any>;
-  attributes: Map<string, any>;
-  childNodes: DebugNode[];
-  nativeElement: any;
-
-  constructor(nativeNode: any, parent: any) {
-    super(nativeNode, parent);
-    this.properties = new Map<string, any>();
-    this.attributes = new Map<string, any>();
-    this.childNodes = [];
-    this.nativeElement = nativeNode;
-  }
-
-  addChild(child: DebugNode) {
-    if (isPresent(child)) {
-      this.childNodes.push(child);
-      child.parent = this;
-    }
-  }
-
-  removeChild(child: DebugNode) {
-    var childIndex = this.childNodes.indexOf(child);
-    if (childIndex !== -1) {
-      child.parent = null;
-      this.childNodes.splice(childIndex, 1);
-    }
-  }
-
-  insertChildrenAfter(child: DebugNode, newChildren: DebugNode[]) {
-    var siblingIndex = this.childNodes.indexOf(child);
-    if (siblingIndex !== -1) {
-      var previousChildren = this.childNodes.slice(0, siblingIndex + 1);
-      var nextChildren = this.childNodes.slice(siblingIndex + 1);
-      this.childNodes =
-          ListWrapper.concat(ListWrapper.concat(previousChildren, newChildren), nextChildren);
-      for (var i = 0; i < newChildren.length; ++i) {
-        var newChild = newChildren[i];
-        if (isPresent(newChild.parent)) {
-          newChild.parent.removeChild(newChild);
-        }
-        newChild.parent = this;
-      }
-    }
-  }
-
-  query(predicate: Predicate<DebugElement>): DebugElement {
-    var results = this.queryAll(predicate);
-    return results.length > 0 ? results[0] : null;
-  }
-
-  queryAll(predicate: Predicate<DebugElement>): DebugElement[] {
-    var matches = [];
-    _queryElementChildren(this, predicate, matches);
-    return matches;
-  }
-
-  queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[] {
-    var matches = [];
-    _queryNodeChildren(this, predicate, matches);
-    return matches;
-  }
-
-  get children(): DebugElement[] {
-    var children = [];
-    this.childNodes.forEach((node) => {
-      if (node instanceof DebugElement) {
-        children.push(node);
-      }
-    });
-    return children;
-  }
-
-  triggerEventHandler(eventName: string, eventObj: Event) {
-    this.listeners.forEach((listener) => {
-      if (listener.name == eventName) {
-        listener.callback(eventObj);
-      }
-    });
-  }
-}
-
-export function asNativeElements(debugEls: DebugElement[]): any {
-  return debugEls.map((el) => el.nativeElement);
-}
-
-function _queryElementChildren(element: DebugElement, predicate: Predicate<DebugElement>,
-                               matches: DebugElement[]) {
-  element.childNodes.forEach(node => {
-    if (node instanceof DebugElement) {
-      if (predicate(node)) {
-        matches.push(node);
-      }
-      _queryElementChildren(node, predicate, matches);
-    }
-  });
-}
-
-function _queryNodeChildren(parentNode: DebugNode, predicate: Predicate<DebugNode>,
-                            matches: DebugNode[]) {
-  if (parentNode instanceof DebugElement) {
-    parentNode.childNodes.forEach(node => {
-      if (predicate(node)) {
-        matches.push(node);
-      }
-      if (node instanceof DebugElement) {
-        _queryNodeChildren(node, predicate, matches);
-      }
-    });
-  }
-}
-
-// Need to keep the nodes in a global Map so that multiple angular apps are supported.
-var _nativeNodeToDebugNode = new Map<any, DebugNode>();
-
-export function getDebugNode(nativeNode: any): DebugNode {
-  return _nativeNodeToDebugNode.get(nativeNode);
-}
-
-export function getAllDebugNodes(): DebugNode[] {
-  return MapWrapper.values(_nativeNodeToDebugNode);
-}
-
-export function indexDebugNode(node: DebugNode) {
-  _nativeNodeToDebugNode.set(node.nativeNode, node);
-}
-
-export function removeDebugNodeFromIndex(node: DebugNode) {
-  _nativeNodeToDebugNode.delete(node.nativeNode);
-}

modules/angular2/src/core/debug/debug_renderer.ts

@@ -1,157 +0,0 @@
-import {isPresent} from 'angular2/src/facade/lang';
-import {
-  Renderer,
-  RootRenderer,
-  RenderComponentType,
-  RenderDebugInfo
-} from 'angular2/src/core/render/api';
-import {
-  DebugNode,
-  DebugElement,
-  EventListener,
-  getDebugNode,
-  indexDebugNode,
-  removeDebugNodeFromIndex
-} from 'angular2/src/core/debug/debug_node';
-
-export class DebugDomRootRenderer implements RootRenderer {
-  constructor(private _delegate: RootRenderer) {}
-
-  renderComponent(componentProto: RenderComponentType): Renderer {
-    return new DebugDomRenderer(this, this._delegate.renderComponent(componentProto));
-  }
-}
-
-export class DebugDomRenderer implements Renderer {
-  constructor(private _rootRenderer: DebugDomRootRenderer, private _delegate: Renderer) {}
-
-  renderComponent(componentType: RenderComponentType): Renderer {
-    return this._rootRenderer.renderComponent(componentType);
-  }
-
-  selectRootElement(selector: string): any {
-    var nativeEl = this._delegate.selectRootElement(selector);
-    var debugEl = new DebugElement(nativeEl, null);
-    indexDebugNode(debugEl);
-    return nativeEl;
-  }
-
-  createElement(parentElement: any, name: string): any {
-    var nativeEl = this._delegate.createElement(parentElement, name);
-    var debugEl = new DebugElement(nativeEl, getDebugNode(parentElement));
-    debugEl.name = name;
-    indexDebugNode(debugEl);
-    return nativeEl;
-  }
-
-  createViewRoot(hostElement: any): any { return this._delegate.createViewRoot(hostElement); }
-
-  createTemplateAnchor(parentElement: any): any {
-    var comment = this._delegate.createTemplateAnchor(parentElement);
-    var debugEl = new DebugNode(comment, getDebugNode(parentElement));
-    indexDebugNode(debugEl);
-    return comment;
-  }
-
-  createText(parentElement: any, value: string): any {
-    var text = this._delegate.createText(parentElement, value);
-    var debugEl = new DebugNode(text, getDebugNode(parentElement));
-    indexDebugNode(debugEl);
-    return text;
-  }
-
-  projectNodes(parentElement: any, nodes: any[]) {
-    var debugParent = getDebugNode(parentElement);
-    if (isPresent(debugParent) && debugParent instanceof DebugElement) {
-      nodes.forEach((node) => { debugParent.addChild(getDebugNode(node)); });
-    }
-    return this._delegate.projectNodes(parentElement, nodes);
-  }
-
-  attachViewAfter(node: any, viewRootNodes: any[]) {
-    var debugNode = getDebugNode(node);
-    if (isPresent(debugNode)) {
-      var debugParent = debugNode.parent;
-      if (viewRootNodes.length > 0 && isPresent(debugParent)) {
-        var debugViewRootNodes = [];
-        viewRootNodes.forEach((rootNode) => debugViewRootNodes.push(getDebugNode(rootNode)));
-        debugParent.insertChildrenAfter(debugNode, debugViewRootNodes);
-      }
-    }
-    return this._delegate.attachViewAfter(node, viewRootNodes);
-  }
-
-  detachView(viewRootNodes: any[]) {
-    viewRootNodes.forEach((node) => {
-      var debugNode = getDebugNode(node);
-      if (isPresent(debugNode) && isPresent(debugNode.parent)) {
-        debugNode.parent.removeChild(debugNode);
-      }
-    });
-    return this._delegate.detachView(viewRootNodes);
-  }
-
-  destroyView(hostElement: any, viewAllNodes: any[]) {
-    viewAllNodes.forEach((node) => { removeDebugNodeFromIndex(getDebugNode(node)); });
-    return this._delegate.destroyView(hostElement, viewAllNodes);
-  }
-
-  listen(renderElement: any, name: string, callback: Function) {
-    var debugEl = getDebugNode(renderElement);
-    if (isPresent(debugEl)) {
-      debugEl.listeners.push(new EventListener(name, callback));
-    }
-    return this._delegate.listen(renderElement, name, callback);
-  }
-
-  listenGlobal(target: string, name: string, callback: Function): Function {
-    return this._delegate.listenGlobal(target, name, callback);
-  }
-
-  setElementProperty(renderElement: any, propertyName: string, propertyValue: any) {
-    var debugEl = getDebugNode(renderElement);
-    if (isPresent(debugEl) && debugEl instanceof DebugElement) {
-      debugEl.properties.set(propertyName, propertyValue);
-    }
-    return this._delegate.setElementProperty(renderElement, propertyName, propertyValue);
-  }
-
-  setElementAttribute(renderElement: any, attributeName: string, attributeValue: string) {
-    var debugEl = getDebugNode(renderElement);
-    if (isPresent(debugEl) && debugEl instanceof DebugElement) {
-      debugEl.attributes.set(attributeName, attributeValue);
-    }
-    return this._delegate.setElementAttribute(renderElement, attributeName, attributeValue);
-  }
-
-  /**
-   * Used only in debug mode to serialize property changes to comment nodes,
-   * such as <template> placeholders.
-   */
-  setBindingDebugInfo(renderElement: any, propertyName: string, propertyValue: string) {
-    return this._delegate.setBindingDebugInfo(renderElement, propertyName, propertyValue);
-  }
-
-  /**
-   * Used only in development mode to set information needed by the DebugNode for this element.
-   */
-  setElementDebugInfo(renderElement: any, info: RenderDebugInfo) {
-    var debugEl = getDebugNode(renderElement);
-    debugEl.setDebugInfo(info);
-    return this._delegate.setElementDebugInfo(renderElement, info);
-  }
-
-  setElementClass(renderElement: any, className: string, isAdd: boolean) {
-    return this._delegate.setElementClass(renderElement, className, isAdd);
-  }
-
-  setElementStyle(renderElement: any, styleName: string, styleValue: string) {
-    return this._delegate.setElementStyle(renderElement, styleName, styleValue);
-  }
-
-  invokeElementMethod(renderElement: any, methodName: string, args: any[]) {
-    return this._delegate.invokeElementMethod(renderElement, methodName, args);
-  }
-
-  setText(renderNode: any, text: string) { return this._delegate.setText(renderNode, text); }
-}

modules/angular2/src/core/di/injector.ts

@@ -17,7 +17,6 @@ import {
   OutOfBoundsError
 } from './exceptions';
 import {FunctionWrapper, Type, isPresent, isBlank, CONST_EXPR} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
 import {Key} from './key';
 import {SelfMetadata, HostMetadata, SkipSelfMetadata} from './metadata';
 
@@ -875,9 +874,6 @@ export class Injector {
           obj = factory(d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d14, d15, d16,
                         d17, d18, d19);
           break;
-        default:
-          throw new BaseException(
-              `Cannot instantiate '${provider.key.displayName}' because it has more than 20 dependencies`);
       }
     } catch (e) {
       throw new InstantiationError(this, e, e.stack, provider.key);

modules/angular2/src/core/di/opaque_token.ts

@@ -9,7 +9,7 @@ import {CONST} from 'angular2/src/facade/lang';
  * var t = new OpaqueToken("value");
  *
  * var injector = Injector.resolveAndCreate([
- *   provide(t, {useValue: "bindingValue"})
+ *   provide(t, {useValue: "providedValue"})
  * ]);
  *
  * expect(injector.get(t)).toEqual("bindingValue");

modules/angular2/src/core/linker/element.ts

@@ -463,11 +463,7 @@ export class AppElement implements DependencyProvider, ElementRef, AfterViewChec
     var inj: AppElement = this;
     while (isPresent(inj)) {
       inj._setQueriesAsDirty();
-      if (isBlank(inj.parent) && inj.parentView.proto.type === ViewType.EMBEDDED) {
-        inj = inj.parentView.containerAppElement;
-      } else {
-        inj = inj.parent;
-      }
+      inj = inj.parent;
     }
   }
 

modules/angular2/src/core/linker/view.ts

@@ -27,7 +27,7 @@ import {
   CONST_EXPR
 } from 'angular2/src/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
-import {Renderer, RootRenderer, RenderDebugInfo} from 'angular2/src/core/render/api';
+import {Renderer, RootRenderer} from 'angular2/src/core/render/api';
 import {ViewRef_, HostViewFactoryRef} from './view_ref';
 import {ProtoPipes} from 'angular2/src/core/pipes/pipes';
 import {camelCaseToDashCase} from 'angular2/src/core/render/util';
@@ -119,12 +119,6 @@ export class AppView implements ChangeDispatcher {
                              (templateName, _) => { localsMap.set(templateName, null); });
     for (var i = 0; i < appElements.length; i++) {
       var appEl = appElements[i];
-      var providerTokens = [];
-      if (isPresent(appEl.proto.protoInjector)) {
-        for (var j = 0; j < appEl.proto.protoInjector.numberOfProviders; j++) {
-          providerTokens.push(appEl.proto.protoInjector.getProviderAtIndex(j).key.token);
-        }
-      }
       StringMapWrapper.forEach(appEl.proto.directiveVariableBindings, (directiveIndex, name) => {
         if (isBlank(directiveIndex)) {
           localsMap.set(name, appEl.nativeElement);
@@ -132,9 +126,6 @@ export class AppView implements ChangeDispatcher {
           localsMap.set(name, appEl.getDirectiveAtIndex(directiveIndex));
         }
       });
-      this.renderer.setElementDebugInfo(
-          appEl.nativeElement, new RenderDebugInfo(appEl.getInjector(), appEl.getComponent(),
-                                                   providerTokens, localsMap));
     }
     var parentLocals = null;
     if (this.proto.type !== ViewType.COMPONENT) {

modules/angular2/src/core/linker/view_listener.ts

@@ -0,0 +1,11 @@
+import {Injectable} from 'angular2/src/core/di';
+import * as viewModule from './view';
+
+/**
+ * Listener for view creation / destruction.
+ */
+@Injectable()
+export class AppViewListener {
+  onViewCreated(view: viewModule.AppView) {}
+  onViewDestroyed(view: viewModule.AppView) {}
+}

modules/angular2/src/core/linker/view_manager.ts

@@ -22,6 +22,7 @@ import {
 } from './view_ref';
 import {ViewContainerRef} from './view_container_ref';
 import {TemplateRef, TemplateRef_} from './template_ref';
+import {AppViewListener} from './view_listener';
 import {RootRenderer, RenderComponentType} from 'angular2/src/core/render/api';
 import {wtfCreateScope, wtfLeave, WtfScopeFn} from '../profile/profile';
 import {APP_ID} from 'angular2/src/core/application_tokens';
@@ -184,7 +185,10 @@ export abstract class AppViewManager {
 export class AppViewManager_ extends AppViewManager {
   private _nextCompTypeId: number = 0;
 
-  constructor(private _renderer: RootRenderer, @Inject(APP_ID) private _appId: string) { super(); }
+  constructor(private _renderer: RootRenderer, private _viewListener: AppViewListener,
+              @Inject(APP_ID) private _appId: string) {
+    super();
+  }
 
   getViewContainer(location: ElementRef): ViewContainerRef {
     return (<ElementRef_>location).internalElement.getViewContainerRef();
@@ -312,10 +316,10 @@ export class AppViewManager_ extends AppViewManager {
   }
 
   /** @internal */
-  onViewCreated(view: AppView) {}
+  onViewCreated(view: AppView) { this._viewListener.onViewCreated(view); }
 
   /** @internal */
-  onViewDestroyed(view: AppView) {}
+  onViewDestroyed(view: AppView) { this._viewListener.onViewDestroyed(view); }
 
   /** @internal */
   createRenderComponentType(encapsulation: ViewEncapsulation,

modules/angular2/src/core/metadata.ts

@@ -1166,7 +1166,7 @@ export var ViewChild: ViewChildFactory = makePropDecorator(ViewChildMetadata);
  *   shown: boolean;
  *
  *   constructor(private @Query(Item) items:QueryList<Item>) {
- *     items.changes.subscribe(() => console.log(items.length));
+ *     items.onChange(() => console.log(items.length));
  *   }
  * }
  * ```
@@ -1268,7 +1268,7 @@ export var Input: InputFactory = makePropDecorator(InputMetadata);
  * @Component({
  *   selector: 'app',
  *   template: `
- *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
+ *     <interval-dir (every-second)="everySecond()" (every-five-seconds)="everyFiveSeconds()">
  *     </interval-dir>
  *   `,
  *   directives: [IntervalDir]

modules/angular2/src/core/metadata/di.ts

@@ -254,7 +254,7 @@ export class ContentChildMetadata extends QueryMetadata {
  *   shown: boolean;
  *
  *   constructor(private @Query(Item) items:QueryList<Item>) {
- *     items.changes.subscribe(() => console.log(items.length));
+ *     items.onChange(() => console.log(items.length));
  *   }
  * }
  * ```

modules/angular2/src/core/metadata/directives.ts

@@ -504,7 +504,7 @@ export class DirectiveMetadata extends InjectableMetadata {
    * @Component({
    *   selector: 'app',
    *   template: `
-   *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
+   *     <interval-dir (every-second)="everySecond()" (every-five-seconds)="everyFiveSeconds()">
    *     </interval-dir>
    *   `,
    *   directives: [IntervalDir]
@@ -1035,7 +1035,7 @@ export class InputMetadata {
  * @Component({
  *   selector: 'app',
  *   template: `
- *     <interval-dir (everySecond)="everySecond()" (everyFiveSeconds)="everyFiveSeconds()">
+ *     <interval-dir (every-second)="everySecond()" (every-five-seconds)="everyFiveSeconds()">
  *     </interval-dir>
  *   `,
  *   directives: [IntervalDir]
@@ -1071,8 +1071,8 @@ export class OutputMetadata {
  * @Directive({selector: '[ngModel]'})
  * class NgModelStatus {
  *   constructor(public control:NgModel) {}
- *   @HostBinding('class.valid') get valid { return this.control.valid; }
- *   @HostBinding('class.invalid') get invalid { return this.control.invalid; }
+ *   @HostBinding('[class.valid]') get valid { return this.control.valid; }
+ *   @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }
  * }
  *
  * @Component({

modules/angular2/src/core/reflection/reflection_capabilities.ts

@@ -83,7 +83,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
   }
 
   /** @internal */
-  _zipTypesAndAnnotations(paramTypes, paramAnnotations): any[][] {
+  _zipTypesAndAnnotaions(paramTypes, paramAnnotations): any[][] {
     var result;
 
     if (typeof paramTypes === 'undefined') {
@@ -119,7 +119,7 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
       var paramAnnotations = this._reflect.getMetadata('parameters', typeOrFunc);
       var paramTypes = this._reflect.getMetadata('design:paramtypes', typeOrFunc);
       if (isPresent(paramTypes) || isPresent(paramAnnotations)) {
-        return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
+        return this._zipTypesAndAnnotaions(paramTypes, paramAnnotations);
       }
     }
     // The array has to be filled with `undefined` because holes would be skipped by `some`

modules/angular2/src/core/render/api.ts

@@ -1,16 +1,10 @@
 import {ViewEncapsulation} from 'angular2/src/core/metadata/view';
-import {Injector} from 'angular2/src/core/di/injector';
 
 export class RenderComponentType {
   constructor(public id: string, public encapsulation: ViewEncapsulation,
               public styles: Array<string | any[]>) {}
 }
 
-export class RenderDebugInfo {
-  constructor(public injector: Injector, public component: any, public providerTokens: any[],
-              public locals: Map<string, any>) {}
-}
-
 export interface ParentRenderer { renderComponent(componentType: RenderComponentType): Renderer; }
 
 export abstract class Renderer implements ParentRenderer {
@@ -48,8 +42,6 @@ export abstract class Renderer implements ParentRenderer {
    */
   abstract setBindingDebugInfo(renderElement: any, propertyName: string, propertyValue: string);
 
-  abstract setElementDebugInfo(renderElement: any, info: RenderDebugInfo);
-
   abstract setElementClass(renderElement: any, className: string, isAdd: boolean);
 
   abstract setElementStyle(renderElement: any, styleName: string, styleValue: string);

modules/angular2/src/core/zone/ng_zone.ts

@@ -1,9 +1,9 @@
 import {ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
-import {normalizeBlank, isPresent, global, ZoneLike} from 'angular2/src/facade/lang';
+import {normalizeBlank, isPresent, global} from 'angular2/src/facade/lang';
 import {ObservableWrapper, EventEmitter} from 'angular2/src/facade/async';
 import {wtfLeave, wtfCreateScope, WtfScopeFn} from '../profile/profile';
 
-export interface NgZoneZone extends ZoneLike {
+export interface NgZoneZone extends Zone {
   /** @internal */
   _innerZone: boolean;
 }
@@ -348,9 +348,8 @@ export class NgZone {
     var errorHandling;
 
     if (enableLongStackTrace) {
-      errorHandling =
-          StringMapWrapper.merge(global.Zone.longStackTraceZone,
-                                 {onError: function(e) { ngZone._notifyOnError(this, e); }});
+      errorHandling = StringMapWrapper.merge(
+          Zone.longStackTraceZone, {onError: function(e) { ngZone._notifyOnError(this, e); }});
     } else {
       errorHandling = {onError: function(e) { ngZone._notifyOnError(this, e); }};
     }
@@ -423,14 +422,14 @@ export class NgZone {
                 fn();
                 ListWrapper.remove(ngZone._pendingTimeouts, id);
               };
-              id = parentSetTimeout.call(this, cb, delay, args);
+              id = parentSetTimeout(cb, delay, args);
               ngZone._pendingTimeouts.push(id);
               return id;
             };
           },
           '$clearTimeout': function(parentClearTimeout) {
             return function(id: number) {
-              parentClearTimeout.call(this, id);
+              parentClearTimeout(id);
               ListWrapper.remove(ngZone._pendingTimeouts, id);
             };
           },

modules/angular2/src/facade/async.ts

@@ -15,16 +15,20 @@ import {toPromise} from 'rxjs/operator/toPromise';
 export {Observable} from 'rxjs/Observable';
 export {Subject} from 'rxjs/Subject';
 
+export namespace NodeJS {
+  export interface Timer {}
+}
+
 export class TimerWrapper {
-  static setTimeout(fn: (...args: any[]) => void, millis: number): number {
+  static setTimeout(fn: (...args: any[]) => void, millis: number): NodeJS.Timer {
     return global.setTimeout(fn, millis);
   }
-  static clearTimeout(id: number): void { global.clearTimeout(id); }
+  static clearTimeout(id: NodeJS.Timer): void { global.clearTimeout(id); }
 
-  static setInterval(fn: (...args: any[]) => void, millis: number): number {
+  static setInterval(fn: (...args: any[]) => void, millis: number): NodeJS.Timer {
     return global.setInterval(fn, millis);
   }
-  static clearInterval(id: number): void { global.clearInterval(id); }
+  static clearInterval(id: NodeJS.Timer): void { global.clearInterval(id); }
 }
 
 export class ObservableWrapper {
@@ -157,4 +161,4 @@ export class EventEmitter<T> extends Subject<T> {
 
     return super.subscribe(schedulerFn, errorFn, completeFn);
   }
-}
+}

modules/angular2/src/facade/collection.dart

@@ -225,19 +225,6 @@ class ListWrapper {
 
 bool isListLikeIterable(obj) => obj is Iterable;
 
-bool areIterablesEqual(Iterable a, Iterable b, Function comparator) {
-  var iterator1 = a.iterator;
-  var iterator2 = b.iterator;
-
-  while (true) {
-    var done1 = !iterator1.moveNext();
-    var done2 = !iterator2.moveNext();
-    if (done1 && done2) return true;
-    if (done1 || done2) return false;
-    if (!comparator(iterator2.current, iterator2.current)) return false;
-  }
-}
-
 void iterateListLike(iter, fn(item)) {
   assert(iter is Iterable);
   for (var item in iter) {

modules/angular2/src/facade/collection.ts

@@ -274,19 +274,6 @@ export function isListLikeIterable(obj: any): boolean {
           getSymbolIterator() in obj);  // JS Iterable have a Symbol.iterator prop
 }
 
-export function areIterablesEqual(a: any, b: any, comparator: Function): boolean {
-  var iterator1 = a[getSymbolIterator()]();
-  var iterator2 = b[getSymbolIterator()]();
-
-  while (true) {
-    let item1 = iterator1.next();
-    let item2 = iterator2.next();
-    if (item1.done && item2.done) return true;
-    if (item1.done || item2.done) return false;
-    if (!comparator(item1.value, item2.value)) return false;
-  }
-}
-
 export function iterateListLike(obj: any, fn: Function) {
   if (isArray(obj)) {
     for (var i = 0; i < obj.length; i++) {

modules/angular2/src/facade/lang.dart

@@ -345,15 +345,9 @@ class DateWrapper {
   }
 }
 
-bool isPrimitive(Object obj) => obj is num || obj is bool || obj == null || obj is String;
-
 // needed to match the exports from lang.js
 var global = null;
 
 dynamic evalExpression(String sourceUrl, String expr, String declarations, Map<String, String> vars) {
   throw "Dart does not support evaluating expression during runtime!";
 }
-
-bool hasConstructor(Object value, Type type) {
-  return value.runtimeType == type;
-}

modules/angular2/src/facade/lang.ts

@@ -1,36 +1,3 @@
-// Zones are TC-39 standards-track so users could choose a different implementation
-// Rather than import {Zone} from 'zone.js' we define an interface
-// so that any library that structurally matches may be used with Angular 2.
-export interface ZoneLike {
-  fork(locals?: any): ZoneLike;
-  run(fn: any, applyTo?: any, applyWith?: any): any;
-}
-export interface ZoneLikeConstructor {
-  longStackTraceZone: { [key: string]: any; };
-}
-
-export interface BrowserNodeGlobal {
-  Object: typeof Object;
-  Array: typeof Array;
-  Map: typeof Map;
-  Set: typeof Set;
-  Date: DateConstructor;
-  RegExp: RegExpConstructor;
-  JSON: typeof JSON;
-  Math: any;  // typeof Math;
-  assert(condition: any): void;
-  Reflect: any;
-  zone: ZoneLike;
-  Zone: ZoneLikeConstructor;
-  getAngularTestability: Function;
-  getAllAngularTestabilities: Function;
-  frameworkStabilizers: Array<Function>;
-  setTimeout: Function;
-  clearTimeout: Function;
-  setInterval: Function;
-  clearInterval: Function;
-}
-
 // TODO(jteplitz602): Load WorkerGlobalScope from lib.webworker.d.ts file #3492
 declare var WorkerGlobalScope;
 var globalScope: BrowserNodeGlobal;
@@ -43,7 +10,7 @@ if (typeof window === 'undefined') {
   }
 } else {
   globalScope = <any>window;
-}
+};
 
 export const IS_DART = false;
 
@@ -460,11 +427,3 @@ export function evalExpression(sourceUrl: string, expr: string, declarations: st
   }
   return new Function(...fnArgNames.concat(fnBody))(...fnArgValues);
 }
-
-export function isPrimitive(obj: any): boolean {
-  return !isJsObject(obj);
-}
-
-export function hasConstructor(value: Object, type: Type): boolean {
-  return value.constructor === type;
-}

modules/angular2/src/http/backends/browser_jsonp.ts

@@ -3,11 +3,11 @@ import {global} from 'angular2/src/facade/lang';
 
 let _nextRequestId = 0;
 export const JSONP_HOME = '__ng_jsonp__';
-var _jsonpConnections: {[key: string]: any} = null;
+var _jsonpConnections = null;
 
 function _getJsonpConnections(): {[key: string]: any} {
   if (_jsonpConnections === null) {
-    _jsonpConnections = (<{[key: string]: any}>global)[JSONP_HOME] = {};
+    _jsonpConnections = global[JSONP_HOME] = {};
   }
   return _jsonpConnections;
 }

modules/angular2/src/http/backends/jsonp_backend.ts

@@ -8,7 +8,6 @@ import {BrowserJsonp} from './browser_jsonp';
 import {makeTypeError} from 'angular2/src/facade/exceptions';
 import {StringWrapper, isPresent} from 'angular2/src/facade/lang';
 import {Observable} from 'rxjs/Observable';
-import {Observer} from 'rxjs/Observer';
 
 const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
 const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';
@@ -52,7 +51,7 @@ export class JSONPConnection_ extends JSONPConnection {
       throw makeTypeError(JSONP_ERR_WRONG_METHOD);
     }
     this.request = req;
-    this.response = new Observable((responseObserver: Observer<Response>) => {
+    this.response = new Observable(responseObserver => {
 
       this.readyState = ReadyState.Loading;
       let id = this._id = _dom.nextRequestID();
@@ -71,7 +70,7 @@ export class JSONPConnection_ extends JSONPConnection {
 
       let script = this._script = _dom.build(url);
 
-      let onLoad = (event: Event) => {
+      let onLoad = event => {
         if (this.readyState === ReadyState.Cancelled) return;
         this.readyState = ReadyState.Done;
         _dom.cleanup(script);
@@ -94,7 +93,7 @@ export class JSONPConnection_ extends JSONPConnection {
         responseObserver.complete();
       };
 
-      let onError = (error: Error) => {
+      let onError = error => {
         if (this.readyState === ReadyState.Cancelled) return;
         this.readyState = ReadyState.Done;
         _dom.cleanup(script);

modules/angular2/src/http/backends/mock_backend.ts

@@ -32,7 +32,7 @@ export class MockConnection implements Connection {
    * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a
    * response is available.
    */
-  response: ReplaySubject<Response>;
+  response: any;  // Subject<Response>
 
   constructor(req: Request) {
     this.response = take.call(new ReplaySubject(1), 1);
@@ -98,15 +98,15 @@ export class MockConnection implements Connection {
  * ### Example
  *
  * ```
- * import {BaseRequestOptions, Http} from 'angular2/http';
+ * import {DefaultOptions, Http} from 'angular2/http';
  * import {MockBackend} from 'angular2/http/testing';
  * it('should get some data', inject([AsyncTestCompleter], (async) => {
  *   var connection;
  *   var injector = Injector.resolveAndCreate([
  *     MockBackend,
- *     provide(Http, {useFactory: (backend, options) => {
- *       return new Http(backend, options);
- *     }, deps: [MockBackend, BaseRequestOptions]})]);
+ *     provide(Http, {useFactory: (backend, defaultOptions) => {
+ *       return new Http(backend, defaultOptions)
+ *     }, deps: [MockBackend, DefaultOptions]})]);
  *   var http = injector.get(Http);
  *   var backend = injector.get(MockBackend);
  *   //Assign any newly-created connection to local variable
@@ -131,8 +131,7 @@ export class MockBackend implements ConnectionBackend {
    * ### Example
    *
    * ```
-   * import {Http, BaseRequestOptions} from 'angular2/http';
-   * import {MockBackend} from 'angular2/http/testing';
+   * import {MockBackend, Http, BaseRequestOptions} from 'angular2/http';
    * import {Injector} from 'angular2/core';
    *
    * it('should get a response', () => {
@@ -140,7 +139,7 @@ export class MockBackend implements ConnectionBackend {
    *   var text; //this will be set from mock response
    *   var injector = Injector.resolveAndCreate([
    *     MockBackend,
-   *     provide(Http, {useFactory: (backend, options) => {
+   *     provide(Http, {useFactory: (backend, options) {
    *       return new Http(backend, options);
    *     }, deps: [MockBackend, BaseRequestOptions]}]);
    *   var backend = injector.get(MockBackend);
@@ -177,8 +176,7 @@ export class MockBackend implements ConnectionBackend {
   constructor() {
     this.connectionsArray = [];
     this.connections = new Subject();
-    this.connections.subscribe((connection: MockConnection) =>
-                                   this.connectionsArray.push(connection));
+    this.connections.subscribe(connection => this.connectionsArray.push(connection));
     this.pendingConnections = new Subject();
   }
 
@@ -189,7 +187,7 @@ export class MockBackend implements ConnectionBackend {
    */
   verifyNoPendingRequests() {
     let pending = 0;
-    this.pendingConnections.subscribe((c: MockConnection) => pending++);
+    this.pendingConnections.subscribe(c => pending++);
     if (pending > 0) throw new BaseException(`${pending} pending connections to be resolved`);
   }
 
@@ -199,7 +197,7 @@ export class MockBackend implements ConnectionBackend {
    *
    * This method only exists in the mock implementation, not in real Backends.
    */
-  resolveAllConnections() { this.connections.subscribe((c: MockConnection) => c.readyState = 4); }
+  resolveAllConnections() { this.connections.subscribe(c => c.readyState = 4); }
 
   /**
    * Creates a new {@link MockConnection}. This is equivalent to calling `new
@@ -207,7 +205,7 @@ export class MockBackend implements ConnectionBackend {
    * emitter of this `MockBackend` instance. This method will usually only be used by tests
    * against the framework itself, not by end-users.
    */
-  createConnection(req: Request): MockConnection {
+  createConnection(req: Request): Connection {
     if (!isPresent(req) || !(req instanceof Request)) {
       throw new BaseException(`createConnection requires an instance of Request, got ${req}`);
     }

modules/angular2/src/http/backends/xhr_backend.ts

@@ -8,9 +8,7 @@ import {Injectable} from 'angular2/core';
 import {BrowserXhr} from './browser_xhr';
 import {isPresent} from 'angular2/src/facade/lang';
 import {Observable} from 'rxjs/Observable';
-import {Observer} from 'rxjs/Observer';
 import {isSuccess, getResponseURL} from '../http_utils';
-
 /**
 * Creates connections using `XMLHttpRequest`. Given a fully-qualified
 * request, an `XHRConnection` will immediately create an `XMLHttpRequest` object and send the
@@ -29,7 +27,7 @@ export class XHRConnection implements Connection {
   readyState: ReadyState;
   constructor(req: Request, browserXHR: BrowserXhr, baseResponseOptions?: ResponseOptions) {
     this.request = req;
-    this.response = new Observable((responseObserver: Observer<Response>) => {
+    this.response = new Observable(responseObserver => {
       let _xhr: XMLHttpRequest = browserXHR.build();
       _xhr.open(RequestMethod[req.method].toUpperCase(), req.url);
       // load event handler
@@ -66,7 +64,7 @@ export class XHRConnection implements Connection {
         responseObserver.error(response);
       };
       // error event handler
-      let onError = (err: any) => {
+      let onError = (err) => {
         var responseOptions = new ResponseOptions({body: err, type: ResponseType.Error});
         if (isPresent(baseResponseOptions)) {
           responseOptions = baseResponseOptions.merge(responseOptions);

modules/angular2/src/http/headers.ts

@@ -9,7 +9,6 @@ import {
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
 import {
   isListLikeIterable,
-  iterateListLike,
   Map,
   MapWrapper,
   StringMapWrapper,
@@ -58,9 +57,8 @@ export class Headers {
     }
 
     // headers instanceof StringMap
-    StringMapWrapper.forEach(headers, (v: any, k: string) => {
-      this._headersMap.set(k, isListLikeIterable(v) ? v : [v]);
-    });
+    StringMapWrapper.forEach(
+        headers, (v, k) => { this._headersMap.set(k, isListLikeIterable(v) ? v : [v]); });
   }
 
   /**
@@ -112,13 +110,13 @@ export class Headers {
    * Sets or overrides header value for given name.
    */
   set(header: string, value: string | string[]): void {
-    var list: string[] = [];
+    var list = [];
 
     if (isListLikeIterable(value)) {
       var pushValue = (<string[]>value).join(',');
       list.push(pushValue);
     } else {
-      list.push(<string>value);
+      list.push(value);
     }
 
     this._headersMap.set(header, list);
@@ -132,17 +130,7 @@ export class Headers {
   /**
    * Returns string of all headers.
    */
-  toJSON(): {[key: string]: any} {
-    let serializableHeaders = {};
-    this._headersMap.forEach((values: string[], name: string) => {
-      let list = [];
-
-      iterateListLike(values, val => list = ListWrapper.concat(list, val.split(',')));
-
-      serializableHeaders[name] = list;
-    });
-    return serializableHeaders;
-  }
+  toJSON(): string { return Json.stringify(this.values()); }
 
   /**
    * Returns list of header values for a given name.

modules/angular2/src/http/http.ts

@@ -12,8 +12,7 @@ function httpRequest(backend: ConnectionBackend, request: Request): Observable<R
   return backend.createConnection(request).response;
 }
 
-function mergeOptions(defaultOpts: BaseRequestOptions, providedOpts: RequestOptionsArgs,
-                      method: RequestMethod, url: string): RequestOptions {
+function mergeOptions(defaultOpts, providedOpts, method, url): RequestOptions {
   var newOptions = defaultOpts;
   if (isPresent(providedOpts)) {
     // Hack so Dart can used named parameters
@@ -105,7 +104,7 @@ export class Http {
     if (isString(url)) {
       responseObservable = httpRequest(
           this._backend,
-          new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, <string>url)));
+          new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, url)));
     } else if (url instanceof Request) {
       responseObservable = httpRequest(this._backend, url);
     } else {
@@ -184,8 +183,7 @@ export class Jsonp extends Http {
   request(url: string | Request, options?: RequestOptionsArgs): Observable<Response> {
     var responseObservable: any;
     if (isString(url)) {
-      url =
-          new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, <string>url));
+      url = new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, url));
     }
     if (url instanceof Request) {
       if (url.method !== RequestMethod.Get) {

modules/angular2/src/http/http_utils.ts

@@ -3,18 +3,16 @@ import {RequestMethod} from './enums';
 import {makeTypeError} from 'angular2/src/facade/exceptions';
 import {Response} from './static_response';
 
-export function normalizeMethodName(method: string | RequestMethod): RequestMethod {
+export function normalizeMethodName(method): RequestMethod {
   if (isString(method)) {
     var originalMethod = method;
-    method = (<string>method)
-                 .replace(/(\w)(\w*)/g, (g0: string, g1: string, g2: string) =>
-                                            g1.toUpperCase() + g2.toLowerCase());
-    method = <number>(<{[key: string]: any}>RequestMethod)[method];
+    method = method.replace(/(\w)(\w*)/g, (g0, g1, g2) => g1.toUpperCase() + g2.toLowerCase());
+    method = RequestMethod[method];
     if (typeof method !== 'number')
       throw makeTypeError(
           `Invalid request method. The method "${originalMethod}" is not supported.`);
   }
-  return <RequestMethod>method;
+  return method;
 }
 
 export const isSuccess = (status: number): boolean => (status >= 200 && status < 300);

modules/angular2/src/http/static_response.ts

@@ -92,7 +92,7 @@ export class Response {
    * Attempts to return body as parsed `JSON` object, or raises an exception.
    */
   json(): any {
-    var jsonResponse: string | Object;
+    var jsonResponse;
     if (isJsObject(this._body)) {
       jsonResponse = this._body;
     } else if (isString(this._body)) {

modules/angular2/src/http/url_search_params.ts

@@ -121,7 +121,7 @@ export class URLSearchParams {
   }
 
   toString(): string {
-    var paramsList: string[] = [];
+    var paramsList = [];
     this.paramsMap.forEach((values, k) => { values.forEach(v => paramsList.push(k + '=' + v)); });
     return paramsList.join('&');
   }

modules/angular2/src/mock/directive_resolver_mock.ts

@@ -69,11 +69,11 @@ export class MockDirectiveResolver extends DirectiveResolver {
     this.viewProviderOverrides.set(type, viewBindings);
   }
 
-  setProvidersOverride(type: Type, providers: any[]): void {
-    this._providerOverrides.set(type, providers);
+  setProvidersOverride(type: Type, bindings: any[]): void {
+    this._providerOverrides.set(type, bindings);
   }
 
-  setViewProvidersOverride(type: Type, viewProviders: any[]): void {
-    this.viewProviderOverrides.set(type, viewProviders);
+  setViewProvidersOverride(type: Type, viewBindings: any[]): void {
+    this.viewProviderOverrides.set(type, viewBindings);
   }
 }

modules/angular2/src/platform/browser_common.ts

@@ -30,12 +30,12 @@ import {BrowserDomAdapter} from './browser/browser_adapter';
 import {BrowserGetTestability} from 'angular2/src/platform/browser/testability';
 import {wtfInit} from 'angular2/src/core/profile/wtf_init';
 import {EventManager, EVENT_MANAGER_PLUGINS} from "angular2/src/platform/dom/events/event_manager";
-import {ELEMENT_PROBE_PROVIDERS} from 'angular2/platform/common_dom';
 export {DOCUMENT} from 'angular2/src/platform/dom/dom_tokens';
 export {Title} from 'angular2/src/platform/browser/title';
 export {
+  DebugElementViewListener,
   ELEMENT_PROBE_PROVIDERS,
-  ELEMENT_PROBE_PROVIDERS_PROD_MODE,
+  ELEMENT_PROBE_BINDINGS,
   inspectNativeElement,
   By
 } from 'angular2/platform/common_dom';
@@ -84,8 +84,7 @@ export const BROWSER_APP_COMMON_PROVIDERS: Array<any /*Type | Provider | any[]*/
   Testability,
   BrowserDetails,
   AnimationBuilder,
-  EventManager,
-  ELEMENT_PROBE_PROVIDERS
+  EventManager
 ]);
 
 export function initDomAdapter() {

modules/angular2/src/platform/dom/debug/by.ts

@@ -39,6 +39,6 @@ export class By {
    * {@example platform/dom/debug/ts/by/by.ts region='by_directive'}
    */
   static directive(type: Type): Predicate<DebugElement> {
-    return (debugElement) => { return debugElement.providerTokens.indexOf(type) !== -1; };
+    return (debugElement) => { return debugElement.hasDirective(type); };
   }
 }

modules/angular2/src/platform/dom/debug/debug_element_view_listener.ts

@@ -0,0 +1,89 @@
+import {CONST_EXPR, isPresent, NumberWrapper, StringWrapper} from 'angular2/src/facade/lang';
+import {MapWrapper, Map, ListWrapper} from 'angular2/src/facade/collection';
+import {Injectable, provide, Provider} from 'angular2/src/core/di';
+import {AppViewListener} from 'angular2/src/core/linker/view_listener';
+import {AppView} from 'angular2/src/core/linker/view';
+import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+import {DebugElement, DebugElement_} from 'angular2/src/core/debug/debug_element';
+
+const NG_ID_PROPERTY = 'ngid';
+const INSPECT_GLOBAL_NAME = 'ng.probe';
+
+const NG_ID_SEPARATOR = '#';
+
+// Need to keep the views in a global Map so that multiple angular apps are supported
+var _allIdsByView = new Map<AppView, number>();
+var _allViewsById = new Map<number, AppView>();
+
+var _nextId = 0;
+
+function _setElementId(element, indices: number[]) {
+  if (isPresent(element) && DOM.isElementNode(element)) {
+    DOM.setData(element, NG_ID_PROPERTY, indices.join(NG_ID_SEPARATOR));
+  }
+}
+
+function _getElementId(element): number[] {
+  var elId = DOM.getData(element, NG_ID_PROPERTY);
+  if (isPresent(elId)) {
+    return elId.split(NG_ID_SEPARATOR).map(partStr => NumberWrapper.parseInt(partStr, 10));
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Returns a {@link DebugElement} for the given native DOM element, or
+ * null if the given native element does not have an Angular view associated
+ * with it.
+ */
+export function inspectNativeElement(element): DebugElement {
+  var elId = _getElementId(element);
+  if (isPresent(elId)) {
+    var view = _allViewsById.get(elId[0]);
+    if (isPresent(view)) {
+      return new DebugElement_(view.appElements[elId[1]]);
+    }
+  }
+  return null;
+}
+
+@Injectable()
+export class DebugElementViewListener implements AppViewListener {
+  constructor() { DOM.setGlobalVar(INSPECT_GLOBAL_NAME, inspectNativeElement); }
+
+  onViewCreated(view: AppView) {
+    var viewId = _nextId++;
+    _allViewsById.set(viewId, view);
+    _allIdsByView.set(view, viewId);
+    for (var i = 0; i < view.appElements.length; i++) {
+      var el = view.appElements[i];
+      _setElementId(el.nativeElement, [viewId, i]);
+    }
+  }
+
+  onViewDestroyed(view: AppView) {
+    var viewId = _allIdsByView.get(view);
+    _allIdsByView.delete(view);
+    _allViewsById.delete(viewId);
+  }
+}
+
+/**
+ * Providers which support debugging Angular applications (e.g. via `ng.probe`).
+ *
+ * ## Example
+ *
+ * {@example platform/dom/debug/ts/debug_element_view_listener/providers.ts region='providers'}
+ */
+export const ELEMENT_PROBE_PROVIDERS: any[] = CONST_EXPR([
+  DebugElementViewListener,
+  CONST_EXPR(new Provider(AppViewListener, {useExisting: DebugElementViewListener})),
+]);
+
+/**
+ * Use {@link ELEMENT_PROBE_PROVIDERS}.
+ *
+ * @deprecated
+ */
+export const ELEMENT_PROBE_BINDINGS = ELEMENT_PROBE_PROVIDERS;

modules/angular2/src/platform/dom/debug/ng_probe.ts

@@ -1,42 +0,0 @@
-import {CONST_EXPR, assertionsEnabled, isPresent} from 'angular2/src/facade/lang';
-import {Injectable, provide, Provider} from 'angular2/src/core/di';
-import {DOM} from 'angular2/src/platform/dom/dom_adapter';
-import {DebugNode, getDebugNode} from 'angular2/src/core/debug/debug_node';
-import {DomRootRenderer} from 'angular2/src/platform/dom/dom_renderer';
-import {RootRenderer} from 'angular2/core';
-import {DebugDomRootRenderer} from 'angular2/src/core/debug/debug_renderer';
-
-
-const INSPECT_GLOBAL_NAME = 'ng.probe';
-
-/**
- * Returns a {@link DebugElement} for the given native DOM element, or
- * null if the given native element does not have an Angular view associated
- * with it.
- */
-export function inspectNativeElement(element): DebugNode {
-  return getDebugNode(element);
-}
-
-function _createConditionalRootRenderer(rootRenderer) {
-  if (assertionsEnabled()) {
-    return _createRootRenderer(rootRenderer);
-  }
-  return rootRenderer;
-}
-
-function _createRootRenderer(rootRenderer) {
-  DOM.setGlobalVar(INSPECT_GLOBAL_NAME, inspectNativeElement);
-  return new DebugDomRootRenderer(rootRenderer);
-}
-
-/**
- * Providers which support debugging Angular applications (e.g. via `ng.probe`).
- */
-export const ELEMENT_PROBE_PROVIDERS: any[] = CONST_EXPR([
-  new Provider(RootRenderer,
-               {useFactory: _createConditionalRootRenderer, deps: [DomRootRenderer]})
-]);
-
-export const ELEMENT_PROBE_PROVIDERS_PROD_MODE: any[] = CONST_EXPR(
-    [new Provider(RootRenderer, {useFactory: _createRootRenderer, deps: [DomRootRenderer]})]);

modules/angular2/src/platform/dom/dom_renderer.ts

@@ -14,12 +14,7 @@ import {
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
 import {DomSharedStylesHost} from './shared_styles_host';
 
-import {
-  Renderer,
-  RootRenderer,
-  RenderComponentType,
-  RenderDebugInfo
-} from 'angular2/src/core/render/api';
+import {Renderer, RootRenderer, RenderComponentType} from 'angular2/core';
 
 import {EventManager} from './events/event_manager';
 
@@ -206,8 +201,6 @@ export class DomRenderer implements Renderer {
     }
   }
 
-  setElementDebugInfo(renderElement: any, info: RenderDebugInfo) {}
-
   setElementClass(renderElement: any, className: string, isAdd: boolean): void {
     if (isAdd) {
       DOM.addClass(renderElement, className);

modules/angular2/src/platform/worker_render_common.ts

@@ -36,7 +36,6 @@ import {BrowserDomAdapter} from './browser/browser_adapter';
 import {wtfInit} from 'angular2/src/core/profile/wtf_init';
 import {MessageBasedRenderer} from 'angular2/src/web_workers/ui/renderer';
 import {MessageBasedXHRImpl} from 'angular2/src/web_workers/ui/xhr_impl';
-import {BrowserPlatformLocation} from 'angular2/src/router/browser_platform_location';
 import {
   ServiceMessageBrokerFactory,
   ServiceMessageBrokerFactory_
@@ -60,13 +59,6 @@ export const WORKER_RENDER_PLATFORM: Array<any /*Type | Provider | any[]*/> = CO
   new Provider(PLATFORM_INITIALIZER, {useValue: initWebWorkerRenderPlatform, multi: true})
 ]);
 
-/**
- * A list of {@link Provider}s. To use the router in a Worker enabled application you must
- * include these providers when setting up the render thread.
- */
-export const WORKER_RENDER_ROUTER: Array<any /*Type | Provider | any[]*/> =
-    CONST_EXPR([BrowserPlatformLocation]);
-
 export const WORKER_RENDER_APPLICATION_COMMON: Array<any /*Type | Provider | any[]*/> = CONST_EXPR([
   APPLICATION_COMMON_PROVIDERS,
   WORKER_RENDER_MESSAGING_PROVIDERS,