chore(release): 2.0.0-rc.3

Use path: '/' instead of 'index: true'

.github/ISSUE_TEMPLATE.md

@@ -1,11 +1,9 @@
-**IMPORTANT**: This repository's issues are reserved for feature requests and bug reports. Do not submit support requests here, see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question. 
-
-
-**Steps to reproduce and a minimal demo of the problem**
-
-_Use https://plnkr.co or similar -- try this template as a starting point: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5_
-
-_What steps should we try in your demo to see the problem?_
+**I'm submitting a ...**  (check one with "x")
+```
+[ ] bug report
+[ ] feature request
+[ ] support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
+```
 
 **Current behavior**
 
@@ -13,4 +11,23 @@ _What steps should we try in your demo to see the problem?_
 **Expected/desired behavior**
 
 
-**Other information**
+**Reproduction of the problem**
+If the current behavior is a bug or you can illustrate your feature request better with an example, please provide the steps to reproduce and if possible a minimal demo of the problem via https://plnkr.co or similar (you can use this template as a starting point: http://plnkr.co/edit/tpl:AvJOMERrnz94ekVua0u5).
+
+
+
+**What is the expected behavior?**
+
+
+
+**What is the motivation / use case for changing the behavior?**
+
+
+
+**Please tell us about your environment:**
+
+* **Angular version:** 2.0.0-rc.X
+ 
+* **Browser:** [all | Chrome XX | Firefox XX | IE XX | Safari XX | Mobile Chrome XX | Android X.X Web Browser | iOS XX Safari | iOS XX UIWebView | iOS XX WKWebView ] 
+ 
+* **Language:** [all | TypeScript X.X | ES6/7 | ES5 | Dart] 

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,24 +1,36 @@
-* **Please check if the PR fulfills these requirements**
+**Please check if the PR fulfills these requirements**
 - [ ] The commit message follows our guidelines: https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit-message-format
 - [ ] Tests for the changes have been added (for bug fixes / features)
 - [ ] Docs have been added / updated (for bug fixes / features)
 
 
-* **What kind of change does this PR introduce?** (Bug fix, feature, docs update, ...)
+**What kind of change does this PR introduce?** (check one with "x")
+```
+[ ] Bugfix
+[ ] Feature
+[ ] Code style update (formatting, local variables)
+[ ] Refactoring (no functional changes, no api changes)
+[ ] Build related changes
+[ ] CI related changes
+[ ] Other... Please describe:
+```
+
+**What is the current behavior?** (You can also link to an open issue here)
 
 
 
-* **What is the current behavior?** (You can also link to an open issue here)
+**What is the new behavior?**
 
 
 
-* **What is the new behavior (if this is a feature change)?**
+**Does this PR introduce a breaking change?** (check one with "x")
+```
+[ ] Yes
+[ ] No
+```
+
+If this PR contains a breaking change, please describe the impact and migration path for existing applications: ...
 
 
-
-* **Does this PR introduce a breaking change?** (What changes might users need to make in their application due to this PR?)
-
-
-
-* **Other information**:
+**Other information**:
 

.gitignore

@@ -21,11 +21,6 @@ tmp
 *.js.deps
 *.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
-
 # Include when developing application packages.
 pubspec.lock
 .c9
@@ -49,3 +44,6 @@ npm-debug.log
 
 # built dart payload tests
 /modules_dart/payload/**/build
+
+# rollup-test output
+/modules/rollup-test/dist/

.travis.yml

@@ -3,135 +3,194 @@ sudo: false
 node_js:
   - '5.4.1'
 
+addons:
+#  firefox: "38.0"
+  apt:
+    sources:
+      # needed to install g++ that is used by npms's native modules
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
+
 branches:
   except:
     - g3_v2_0
 
 cache:
   directories:
-    - $HOME/.pub-cache
-    - $HOME/.chrome/chromium
+     - ./node_modules
+     - ./.chrome/chromium
+#    - $HOME/.pub-cache
 
-before_cache:
-  # Undo the pollution of the typescript_next build before the cache is primed for future use
-  - if [[ "$MODE" == "typescript_next" ]]; then npm install typescript; fi
+
+#before_cache:
+#  # Undo the pollution of the typescript_next build before the cache is primed for future use
+#  - if [[ "$MODE" == "typescript_next" ]]; then npm install typescript; fi
 
 env:
   global:
-    # Use newer verison of GCC to that is required to compile native npm modules for Node v4+ on Ubuntu Precise
-    # more info: https://docs.travis-ci.com/user/languages/javascript-with-nodejs#Node.js-v4-(or-io.js-v3)-compiler-requirements
-    - CXX=g++-4.8
-    - KARMA_DART_BROWSERS=DartiumWithWebPlatform
-    # No sandbox mode is needed for Chromium in Travis, it crashes otherwise: https://sites.google.com/a/chromium.org/chromedriver/help/chrome-doesn-t-start
-    - KARMA_JS_BROWSERS=ChromeNoSandbox
-    - E2E_BROWSERS=ChromeOnTravis
-    - LOGS_DIR=/tmp/angular-build/logs
-    - SAUCE_USERNAME=angular-ci
-    - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
-    - BROWSER_STACK_USERNAME=angularteam1
-    - BROWSER_STACK_ACCESS_KEY=BWCd4SynLzdDcv8xtzsB
-    - ARCH=linux-x64
-    - DART_DEV_VERSION=latest
-    - DART_STABLE_VERSION=latest
-    - DART_CHANNEL=stable
-    - DART_VERSION=$DART_STABLE_VERSION
-    # Token for tsd to increase github rate limit
-    # See https://github.com/DefinitelyTyped/tsd#tsdrc
-    # This does not use http://docs.travis-ci.com/user/environment-variables/#Secure-Variables
-    # 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)
-    - TSDRC='{"token":"ef474500309daea53d5991b3079159a29520a40b"}'
+#    - KARMA_JS_BROWSERS=ChromeNoSandbox
+#    - E2E_BROWSERS=ChromeOnTravis
+#    - LOGS_DIR=/tmp/angular-build/logs
+#    - ARCH=linux-x64
+
     # GITHUB_TOKEN_ANGULAR
+    # This is needed for the e2e Travis matrix task to publish packages to github for continuous packages delivery.
     - secure: "fq/U7VDMWO8O8SnAQkdbkoSe2X92PVqg4d044HmRYVmcf6YbO48+xeGJ8yOk0pCBwl3ISO4Q2ot0x546kxfiYBuHkZetlngZxZCtQiFT9kyId8ZKcYdXaIW9OVdw3Gh3tQyUwDucfkVhqcs52D6NZjyE2aWZ4/d1V4kWRO/LMgo="
   matrix:
     # Order: a slower build first, so that we don't occupy an idle travis worker waiting for others to complete.
-    - MODE=dart
-    - MODE=dart DART_CHANNEL=dev
-    - MODE=saucelabs_required
-    - MODE=browserstack_required
-    - MODE=saucelabs_optional
-    - MODE=browserstack_optional
-    - MODE=dart_ddc
-    - MODE=js
-    - MODE=router
-    - MODE=build_only
-    - MODE=typescript_next
-    - MODE=lint
-    - MODE=payload
+   - CI_MODE=js
+   - CI_MODE=e2e
+   - CI_MODE=saucelabs_required
+   - CI_MODE=browserstack_required
+   - CI_MODE=saucelabs_optional
+   - CI_MODE=browserstack_optional
 
 matrix:
   allow_failures:
-    - env: "MODE=saucelabs_optional"
-    - env: "MODE=browserstack_optional"
-    # Tracked in https://github.com/angular/angular/issues/7050
-    - env: "MODE=typescript_next"
+    - env: "CI_MODE=saucelabs_optional"
+    - env: "CI_MODE=browserstack_optional"
 
-addons:
-  firefox: "38.0"
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.8
-
-before_install:
-  - node tools/analytics/build-analytics start ci job
-  - node tools/analytics/build-analytics start ci before_install
-  - echo ${TSDRC} > .tsdrc
-  - export CHROME_BIN=$HOME/.chrome/chromium/chrome-linux/chrome
-  - export DISPLAY=:99.0
-  - export GIT_SHA=$(git rev-parse HEAD)
-  - ./scripts/ci/init_android.sh
-  - sh -e /etc/init.d/xvfb start
-  # Use a separate SauseLabs account for upstream/master builds in order for Sauce to create a badge representing the status of just upstream/master
-  - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_BRANCH}" = "master" ] && SAUCE_USERNAME="angular2-ci" && SAUCE_ACCESS_KEY="693ebc16208a-0b5b-1614-8d66-a2662f4e" || true'
-  - node tools/analytics/build-analytics success ci before_install
 
 install:
-  - node tools/analytics/build-analytics start ci install
-  # Install version of npm that we are locked against
-  - npm install -g npm@3.5.3
-  # Install version of Chromium that we are locked against
-  - ./scripts/ci/install_chromium.sh
-  # Install version of Dart based on the matrix build variables
-  - ./scripts/ci/install_dart.sh ${DART_CHANNEL} ${DART_VERSION} ${ARCH}
-  # Print the size of caches to ease debugging
-  - du -sh ./node_modules || true
-  # Install npm dependecies
-  # check-node-modules will exit(1) if we don't need to install
-  # we need to manually kick off the postinstall script if check-node-modules exit(0)s
-  - node tools/npm/check-node-modules --purge && npm install || npm run postinstall
-  - node tools/analytics/build-analytics success ci install
+  - ./scripts/ci-lite/install.sh
 
 before_script:
-  - node tools/analytics/build-analytics start ci before_script
-  - mkdir -p $LOGS_DIR
-  - ./scripts/ci/presubmit-queue-setup.sh
-  - node tools/analytics/build-analytics success ci before_script
+
 
 script:
-  - node tools/analytics/build-analytics start ci script
-  - ./scripts/ci/build_and_test.sh ${MODE}
-  - node tools/analytics/build-analytics success ci script
+  - ./scripts/ci-lite/build.sh && ./scripts/ci-lite/test.sh
 
 after_script:
-  - node tools/analytics/build-analytics start ci after_script
-  - ./scripts/ci/print-logs.sh
-  - ./scripts/ci/after-script.sh
-  - ./scripts/publish/publish-build-artifacts.sh
-  - node tools/analytics/build-analytics success ci after_script
-  - tools/analytics/build-analytics $TRAVIS_TEST_RESULT ci job
+  - ./scripts/ci-lite/cleanup.sh
 
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/1ef62e23078036f9cee4
-      # trigger Buildtime Trend Service to parse Travis CI log
-      - https://buildtimetrend.herokuapp.com/travis
-      - http://104.197.9.155:8484/hubot/travis/activity
-    on_success: always  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # default: never
-  slack:
-    secure: EP4MzZ8JMyNQJ4S3cd5LEPWSMjC7ZRdzt3veelDiOeorJ6GwZfCDHncR+4BahDzQAuqyE/yNpZqaLbwRWloDi15qIUsm09vgl/1IyNky1Sqc6lEknhzIXpWSalo4/T9ZP8w870EoDvM/UO+LCV99R3wS8Nm9o99eLoWVb2HIUu0=
+
+#branches:
+#  except:
+#    - g3_v2_0
+#
+#cache:
+#  directories:
+#    - $HOME/.pub-cache
+#    - $HOME/.chrome/chromium
+#
+#before_cache:
+#  # Undo the pollution of the typescript_next build before the cache is primed for future use
+#  - if [[ "$MODE" == "typescript_next" ]]; then npm install typescript; fi
+#
+#env:
+#  global:
+#    # Use newer verison of GCC to that is required to compile native npm modules for Node v4+ on Ubuntu Precise
+#    # more info: https://docs.travis-ci.com/user/languages/javascript-with-nodejs#Node.js-v4-(or-io.js-v3)-compiler-requirements
+#    - CXX=g++-4.8
+#    - KARMA_DART_BROWSERS=DartiumWithWebPlatform
+#    # No sandbox mode is needed for Chromium in Travis, it crashes otherwise: https://sites.google.com/a/chromium.org/chromedriver/help/chrome-doesn-t-start
+#    - KARMA_JS_BROWSERS=ChromeNoSandbox
+#    - E2E_BROWSERS=ChromeOnTravis
+#    - LOGS_DIR=/tmp/angular-build/logs
+#    - SAUCE_USERNAME=angular-ci
+#    - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
+#    - BROWSER_STACK_USERNAME=angularteam1
+#    - BROWSER_STACK_ACCESS_KEY=BWCd4SynLzdDcv8xtzsB
+#    - ARCH=linux-x64
+#    - DART_DEV_VERSION=latest
+#    - DART_STABLE_VERSION=latest
+#    - DART_CHANNEL=stable
+#    - DART_VERSION=$DART_STABLE_VERSION
+#    # Token for tsd to increase github rate limit
+#    # See https://github.com/DefinitelyTyped/tsd#tsdrc
+#    # This does not use http://docs.travis-ci.com/user/environment-variables/#Secure-Variables
+#    # 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)
+#    - TSDRC='{"token":"ef474500309daea53d5991b3079159a29520a40b"}'
+#    # GITHUB_TOKEN_ANGULAR
+#    - secure: "fq/U7VDMWO8O8SnAQkdbkoSe2X92PVqg4d044HmRYVmcf6YbO48+xeGJ8yOk0pCBwl3ISO4Q2ot0x546kxfiYBuHkZetlngZxZCtQiFT9kyId8ZKcYdXaIW9OVdw3Gh3tQyUwDucfkVhqcs52D6NZjyE2aWZ4/d1V4kWRO/LMgo="
+#  matrix:
+#    # Order: a slower build first, so that we don't occupy an idle travis worker waiting for others to complete.
+#    - MODE=dart
+#    - MODE=dart DART_CHANNEL=dev
+#    - MODE=saucelabs_required
+#    - MODE=browserstack_required
+#    - MODE=saucelabs_optional
+#    - MODE=browserstack_optional
+#    - MODE=dart_ddc
+#    - MODE=js
+#    - MODE=router
+#    - MODE=build_only
+#    - MODE=typescript_next
+#    - MODE=lint
+#
+#matrix:
+#  allow_failures:
+#    - env: "MODE=saucelabs_optional"
+#    - env: "MODE=browserstack_optional"
+#
+#addons:
+#  firefox: "38.0"
+#  apt:
+#    sources:
+#      - ubuntu-toolchain-r-test
+#    packages:
+#      - g++-4.8
+#
+#before_install:
+#  - node tools/analytics/build-analytics start ci job
+#  - node tools/analytics/build-analytics start ci before_install
+#  - echo ${TSDRC} > .tsdrc
+#  - export CHROME_BIN=$HOME/.chrome/chromium/chrome-linux/chrome
+#  - export DISPLAY=:99.0
+#  - export GIT_SHA=$(git rev-parse HEAD)
+#  - ./scripts/ci/init_android.sh
+#  - sh -e /etc/init.d/xvfb start
+#  # Use a separate SauseLabs account for upstream/master builds in order for Sauce to create a badge representing the status of just upstream/master
+#  - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_BRANCH}" = "master" ] && SAUCE_USERNAME="angular2-ci" && SAUCE_ACCESS_KEY="693ebc16208a-0b5b-1614-8d66-a2662f4e" || true'
+#  - node tools/analytics/build-analytics success ci before_install
+#
+#install:
+#  - node tools/analytics/build-analytics start ci install
+#  # Install version of npm that we are locked against
+#  - npm install -g npm@3.5.3
+#  # Install version of Chromium that we are locked against
+#  - ./scripts/ci/install_chromium.sh
+#  # Install version of Dart based on the matrix build variables
+#  - ./scripts/ci/install_dart.sh ${DART_CHANNEL} ${DART_VERSION} ${ARCH}
+#  # Print the size of caches to ease debugging
+#  - du -sh ./node_modules || true
+#  # Install npm dependecies
+#  # check-node-modules will exit(1) if we don't need to install
+#  # we need to manually kick off the postinstall script if check-node-modules exit(0)s
+#  - node tools/npm/check-node-modules --purge && npm install || npm run postinstall
+#  - node tools/analytics/build-analytics success ci install
+#
+#before_script:
+#  - node tools/analytics/build-analytics start ci before_script
+#  - mkdir -p $LOGS_DIR
+#  - ./scripts/ci/presubmit-queue-setup.sh
+#  - node tools/analytics/build-analytics success ci before_script
+#
+#script:
+#  - node tools/analytics/build-analytics start ci script
+#  - ./scripts/ci/build_and_test.sh ${MODE}
+#  - node tools/analytics/build-analytics success ci script
+#
+#after_script:
+#  - node tools/analytics/build-analytics start ci after_script
+#  - ./scripts/ci/print-logs.sh
+#  - ./scripts/ci/after-script.sh
+#  - ./scripts/publish/publish-build-artifacts.sh
+#  - node tools/analytics/build-analytics success ci after_script
+#  - tools/analytics/build-analytics $TRAVIS_TEST_RESULT ci job
+#
+#notifications:
+#  webhooks:
+#    urls:
+#      - https://webhooks.gitter.im/e/1ef62e23078036f9cee4
+#      # trigger Buildtime Trend Service to parse Travis CI log
+#      - https://buildtimetrend.herokuapp.com/travis
+#      - http://104.197.9.155:8484/hubot/travis/activity
+#    on_success: always  # options: [always|never|change] default: always
+#    on_failure: always  # options: [always|never|change] default: always
+#    on_start: never     # default: never
+#  slack:
+#    secure: EP4MzZ8JMyNQJ4S3cd5LEPWSMjC7ZRdzt3veelDiOeorJ6GwZfCDHncR+4BahDzQAuqyE/yNpZqaLbwRWloDi15qIUsm09vgl/1IyNky1Sqc6lEknhzIXpWSalo4/T9ZP8w870EoDvM/UO+LCV99R3wS8Nm9o99eLoWVb2HIUu0=

CHANGELOG.md

@@ -1,3 +1,616 @@
+<a name="2.0.0-rc.2"></a>
+# 2.0.0-rc.2 (2016-06-15)
+
+
+### Bug Fixes
+
+* **Animation:** Problem with decimals using commas as decimal separation ([5f3d02b](https://github.com/angular/angular/commit/5f3d02b)), closes [#6335](https://github.com/angular/angular/issues/6335) [#6338](https://github.com/angular/angular/issues/6338)
+* **animations:** Ensure AUTO styles are cleared at the end of the state-change animation ([55860e1](https://github.com/angular/angular/commit/55860e1)), closes [#9014](https://github.com/angular/angular/issues/9014) [#9015](https://github.com/angular/angular/issues/9015)
+* **animations:** Ensure the web-animations driver converts style props to camel-case ([4d51158](https://github.com/angular/angular/commit/4d51158)), closes [#9111](https://github.com/angular/angular/issues/9111) [#9112](https://github.com/angular/angular/issues/9112)
+* **bootstrap:** Swap coreBootstrap() and coreLoadAndBootstrap() arguments ([f95a604](https://github.com/angular/angular/commit/f95a604))
+* **browser:** Platform code cleanup ([75e6dfb](https://github.com/angular/angular/commit/75e6dfb))
+* **build:** Change publish-build-artifacts.sh to work with new packaging system ([d414734](https://github.com/angular/angular/commit/d414734))
+* **build:** Declare the secure GITHUB_TOKEN_ANGULAR for package publishing from Travis ([ff40072](https://github.com/angular/angular/commit/ff40072))
+* **build:** Fix an error in package publishing step where the script errors when a UMD bundl ([bac1a6e](https://github.com/angular/angular/commit/bac1a6e))
+* **build:** Fix broken e2e test Travis task by running the right variation of sed on Travis ([267d864](https://github.com/angular/angular/commit/267d864))
+* **build:** Force a compatible baseURL for systemjs-builder ([e0c83f6](https://github.com/angular/angular/commit/e0c83f6)), closes [#7167](https://github.com/angular/angular/issues/7167) [#7360](https://github.com/angular/angular/issues/7360)
+* **build:** Hook up publish-build-artifacts to Travis ([97a1084](https://github.com/angular/angular/commit/97a1084))
+* **build:** Release compiler_cli packages along with rest of @angular packages and use ANGUL ([9a05ca9](https://github.com/angular/angular/commit/9a05ca9))
+* **build:** update API spec to include the return value. ([b60eecf](https://github.com/angular/angular/commit/b60eecf))
+* **ci:** extra API in public_api_spec ([f154e2c](https://github.com/angular/angular/commit/f154e2c))
+* **ci:** incorrect import ([cb980d3](https://github.com/angular/angular/commit/cb980d3))
+* **ci:** make ci fail when compiler integration test fails ([5941c92](https://github.com/angular/angular/commit/5941c92a31aee3b7e0300f5ab91acb3c68b95171))
+* **codegen:** codegen all files in the program, not just roots ([0d71345](https://github.com/angular/angular/commit/0d71345)), closes [#8475](https://github.com/angular/angular/issues/8475)
+* **compiler:** Support for comment finishing with multiple dashes ([60a2ba8](https://github.com/angular/angular/commit/60a2ba8)), closes [#7119](https://github.com/angular/angular/issues/7119)
+* **compiler:** Added support for '* as m' style imports. (#9077) ([e178ee4](https://github.com/angular/angular/commit/e178ee4))
+* **compiler:** Added unit test to ReflectorHost and fixed issues (#9052) ([0658eb4](https://github.com/angular/angular/commit/0658eb4)), closes [(#9052](https://github.com/(/issues/9052)
+* **compiler:** allow --noImplicitAny ([817ddfa](https://github.com/angular/angular/commit/817ddfa))
+* **compiler:** allow decorators defined in the same file ([c1154b3](https://github.com/angular/angular/commit/c1154b3))
+* **compiler:** emit correct types for literal arrays and maps. ([a81923b](https://github.com/angular/angular/commit/a81923b))
+* **compiler:** have CSS parser support nested parentheses inside functions ([ceac045](https://github.com/angular/angular/commit/ceac045)), closes [#7580](https://github.com/angular/angular/issues/7580)
+* **compiler:** Improved error reporting of the static reflector. ([cf3548a](https://github.com/angular/angular/commit/cf3548a)), closes [#8978](https://github.com/angular/angular/issues/8978) [#9011](https://github.com/angular/angular/issues/9011)
+* **compiler:** properly report missing DI tokens (#9065) ([3aca5ff](https://github.com/angular/angular/commit/3aca5ff)), closes [#8245](https://github.com/angular/angular/issues/8245)
+* **compiler:** Reflector generates imports for '..' relative modules. ([35ea02f](https://github.com/angular/angular/commit/35ea02f)), closes [#9003](https://github.com/angular/angular/issues/9003) [#9004](https://github.com/angular/angular/issues/9004)
+* **compiler:** report errors for queries without selectors (#9018) ([057abef](https://github.com/angular/angular/commit/057abef)), closes [#4489](https://github.com/angular/angular/issues/4489)
+* **compiler:** support lifecycle hooks in compiler_cli ([7150ace](https://github.com/angular/angular/commit/7150ace))
+* **compiler:** support string tokens with `.` inside. ([67c80fb](https://github.com/angular/angular/commit/67c80fb)), closes [#8178](https://github.com/angular/angular/issues/8178)
+* **compiler:** throw an error if variable with the same name is already defined. (#7209) ([9036f78](https://github.com/angular/angular/commit/9036f78))
+* **compiler_cli:** allow to use builtin directives like `NgIf`, … ([edec158](https://github.com/angular/angular/commit/edec158)), closes [#8454](https://github.com/angular/angular/issues/8454)
+* **compiler_cli:** normalize used directives ([ff36b03](https://github.com/angular/angular/commit/ff36b03)), closes [#8677](https://github.com/angular/angular/issues/8677)
+* **Control:** Support select multiple with Control class (#8069) ([84f859d](https://github.com/angular/angular/commit/84f859d))
+* **core:** accurate dev mode message for dart (#8403) ([19e6538](https://github.com/angular/angular/commit/19e6538))
+* **core:** don’t detach nested view containers when destroying a view ([e2b1e15](https://github.com/angular/angular/commit/e2b1e15)), closes [#8458](https://github.com/angular/angular/issues/8458) [#8471](https://github.com/angular/angular/issues/8471)
+* **core:** fix build ([3ff20cd](https://github.com/angular/angular/commit/3ff20cd))
+* **core:** fix type of `DebugNode.properties` (#8964) ([ddd2ac4](https://github.com/angular/angular/commit/ddd2ac4)), closes [(#8964](https://github.com/(/issues/8964)
+* **core:** Keep core exports separate from core/testing exports. ([f4f6b87](https://github.com/angular/angular/commit/f4f6b87))
+* **core:** Keep core exports separate from core/testing exports. (#8930) ([21fc1bb](https://github.com/angular/angular/commit/21fc1bb))
+* **core:** remove @internal annotation from PLATFORM_CORE_PROVIDERS ([2ab1085](https://github.com/angular/angular/commit/2ab1085)), closes [#8819](https://github.com/angular/angular/issues/8819)
+* **core:** QueryList documentation (#8976) ([b160ada](https://github.com/angular/angular/commit/b160ada))
+* **di:** type error in InvalidProviderError ([c43636f](https://github.com/angular/angular/commit/c43636f)), closes [#7729](https://github.com/angular/angular/issues/7729)
+* **doc:** Add missing comma in example (#8769) ([00475f2](https://github.com/angular/angular/commit/00475f2))
+* **docs:** Fix a missing opening bracket (#8331) ([d75f928](https://github.com/angular/angular/commit/d75f928)), closes [(#8331](https://github.com/(/issues/8331)
+* **DomRegistry:** fix svg support ([307d105](https://github.com/angular/angular/commit/307d105))
+* **facade:** change EventEmitter to be sync by default (#8761) ([e5904f4](https://github.com/angular/angular/commit/e5904f4))
+* **forms:** radio buttons with different names should not share state ([6dc88f5](https://github.com/angular/angular/commit/6dc88f5)), closes [#7051](https://github.com/angular/angular/issues/7051)
+* **forms:** rename old forms folder to forms-deprecated ([515a8e0](https://github.com/angular/angular/commit/515a8e0))
+* **forms:** update accessor value when native select value changes ([7a2ce7f](https://github.com/angular/angular/commit/7a2ce7f)), closes [#8710](https://github.com/angular/angular/issues/8710)
+* **forms:** update value and validity when controls are added ([50acb96](https://github.com/angular/angular/commit/50acb96)), closes [#8826](https://github.com/angular/angular/issues/8826)
+* **forms:** separate ngModelGroup from formGroupName ([5c0cfde](https://github.com/angular/angular/commit/5c0cfdee48ba5aa48528a1c20ffd99318ee716ae))
+* **HTMLParser:** properly report errors for not properly closed tags (#8999) ([6f281ab](https://github.com/angular/angular/commit/6f281ab)), closes [(#8999](https://github.com/(/issues/8999) [#7849](https://github.com/angular/angular/issues/7849)
+* **http:** remove peerDep on @angular/common ([29c2dcf](https://github.com/angular/angular/commit/29c2dcf))
+* **http:** respect custom Content-Type header in XHRConnection (#9131) ([537e99b](https://github.com/angular/angular/commit/537e99b)), closes [#9130](https://github.com/angular/angular/issues/9130)
+* **http:** Set response.ok ([9234035](https://github.com/angular/angular/commit/9234035)), closes [#6390](https://github.com/angular/angular/issues/6390) [#6503](https://github.com/angular/angular/issues/6503)
+* **Location:** make Location#platformStrategy:LocationStrategy property private ([e93b3d2](https://github.com/angular/angular/commit/e93b3d2))
+* **metadata:** Allow spacing in multiple selectors (#7418) ([b2e804c](https://github.com/angular/angular/commit/b2e804c))
+* **ngc:** depend on correct tsc-wrapped package ([16ef21d](https://github.com/angular/angular/commit/16ef21d))
+* **ngSwitch:** use switchCase instead of switchWhen (#9076) ([e1fcab7](https://github.com/angular/angular/commit/e1fcab7))
+* **ngUpgrade:** prevent digest already in progress (#9054) ([7cefec7](https://github.com/angular/angular/commit/7cefec7))
+* **pipes:** handle undefined value in slice ([83c19a1](https://github.com/angular/angular/commit/83c19a1)), closes [#7152](https://github.com/angular/angular/issues/7152)
+* **platform-browser:** fix rollup config ([f4b9728](https://github.com/angular/angular/commit/f4b9728))
+* **platform-browser:** split dynamic bits in platform-browser into platform-browser-dynamic ([6fc267f](https://github.com/angular/angular/commit/6fc267f22ccb392f2df9808d0415bc690b77a82f))
+* **platform-server:** should declare it's dependency on parse5 via package.json ([9485f5a](https://github.com/angular/angular/commit/9485f5a))
+* **platform-server:** correctly import private DOMTestComponentRenderer ([7afee97](https://github.com/angular/angular/commit/7afee97d1b837cdc808b0a5e5206c306f5700263))
+* **playground:** fix WebWorker single_thread example ([29c77df](https://github.com/angular/angular/commit/29c77df))
+* **query:** set fixed `@ViewChild` / `@ContentChild` right after the view is created ([c3d2459](https://github.com/angular/angular/commit/c3d2459)), closes [#9040](https://github.com/angular/angular/issues/9040)
+* **renderer:** remove unecessary setElementStyles method ([e504d4e](https://github.com/angular/angular/commit/e504d4e)), closes [#9000](https://github.com/angular/angular/issues/9000) [#9009](https://github.com/angular/angular/issues/9009)
+* **Renderer:** update signatures to make RenderDebugInfo optional ([b7b5678](https://github.com/angular/angular/commit/b7b5678)), closes [#8466](https://github.com/angular/angular/issues/8466) [#8859](https://github.com/angular/angular/issues/8859)
+* **Request:** Change Request.text's return type to string ([b2e0946](https://github.com/angular/angular/commit/b2e0946)), closes [#8138](https://github.com/angular/angular/issues/8138)
+* **router:** Added pushState fallback for IE 9 browser. ([bab6023](https://github.com/angular/angular/commit/bab6023)), closes [#6506](https://github.com/angular/angular/issues/6506) [#7929](https://github.com/angular/angular/issues/7929)
+* **router:** browser back and forward buttons not working correctly. ([595bcdd](https://github.com/angular/angular/commit/595bcdd)), closes [#8524](https://github.com/angular/angular/issues/8524) [#8532](https://github.com/angular/angular/issues/8532)
+* **router:** don't mark the RouterOutletMap as internal ([45de65b](https://github.com/angular/angular/commit/45de65b))
+* **router:** ensuring MatchedUrl pass query params ([7d853dd](https://github.com/angular/angular/commit/7d853dd))
+* **router:** openning links in new tab ([fa2ce81](https://github.com/angular/angular/commit/fa2ce81)), closes [#5908](https://github.com/angular/angular/issues/5908) [#6806](https://github.com/angular/angular/issues/6806) [#7749](https://github.com/angular/angular/issues/7749) [#8806](https://github.com/angular/angular/issues/8806) [#8821](https://github.com/angular/angular/issues/8821)
+* **router:** provide a top-level route segment for injection ([b8136cc](https://github.com/angular/angular/commit/b8136cc))
+* **router:** replace state when path is equal to current path (#8766) ([b2a7fd0](https://github.com/angular/angular/commit/b2a7fd0))
+* **Router:** do not kill event-emitter on navigation failure ([cbeeff2](https://github.com/angular/angular/commit/cbeeff2)), closes [#7692](https://github.com/angular/angular/issues/7692) [#7532](https://github.com/angular/angular/issues/7532) [#7692](https://github.com/angular/angular/issues/7692)
+* **Router:** replace state when normalized path is equal to current normalized path ([2bf21e1](https://github.com/angular/angular/commit/2bf21e1)), closes [#7829](https://github.com/angular/angular/issues/7829) [#7897](https://github.com/angular/angular/issues/7897)
+* **scripts:** fix: correct failing to push into builds repo on rerun  ([17f317d](https://github.com/angular/angular/commit/17f317d31efbd68bc6bec73f56c8ce039825d23b))
+* **security:** support XSSI prefixes with and without commas. ([729dc3b](https://github.com/angular/angular/commit/729dc3b))
+* **test-runner:** make karma internal reporter compatible with 0.13.20 (#8977) ([fe8a7b0](https://github.com/angular/angular/commit/fe8a7b0))
+* **testing:**  add discardPeriodicTasks to be used with fakeAsync (#8629) ([0cb93a4](https://github.com/angular/angular/commit/0cb93a4)), closes [#8616](https://github.com/angular/angular/issues/8616)
+* **tests:** Execute the security specs only once ([9634e8d](https://github.com/angular/angular/commit/9634e8d))
+* **travis:** pin the version of tsickle for offline_compiler_test ([7aa1790](https://github.com/angular/angular/commit/7aa1790))
+* **tsickle:** put the tsickle support code at EOF ([3cfe281](https://github.com/angular/angular/commit/3cfe281))
+* **typings:** remove rxjs workaround ([798bfac](https://github.com/angular/angular/commit/798bfac)), closes [#7198](https://github.com/angular/angular/issues/7198)
+* **upgrade:** allow deeper nesting of ng2 components/directives (#8949) ([48bf349](https://github.com/angular/angular/commit/48bf349))
+* **upgrade:** allow functions for template and templateUrl (#9022) ([a19c4e8](https://github.com/angular/angular/commit/a19c4e8))
+* **upgrade:** Ensure upgrade adapter works on angular.js 1.2 (#8647) ([cbc8d0a](https://github.com/angular/angular/commit/cbc8d0a))
+* **upgrade:** fallback to root ng2 injector when element is compiled outside the document (#86 ([db82906](https://github.com/angular/angular/commit/db82906))
+* **upgrade:** make bindings available on $scope in controller & link function (#8645) ([6cdc53c](https://github.com/angular/angular/commit/6cdc53c))
+
+### Features
+
+* **animations:** provide support for offline compilation ([fa0718b](https://github.com/angular/angular/commit/fa0718b))
+* **animations:** support styling of the default animation state ([36d25f2](https://github.com/angular/angular/commit/36d25f2)), closes [#9013](https://github.com/angular/angular/issues/9013)
+* **build:** Added a version stamp in .metadata.json files. ([2d8f776](https://github.com/angular/angular/commit/2d8f776)), closes [#8974](https://github.com/angular/angular/issues/8974) [#8981](https://github.com/angular/angular/issues/8981)
+* **ChangeDetectorRef:** make detectChanges() correct ([6028368](https://github.com/angular/angular/commit/6028368)), closes [#8599](https://github.com/angular/angular/issues/8599)
+* **common:** DatePipe supports ISO string ([abc266f](https://github.com/angular/angular/commit/abc266f)), closes [#7794](https://github.com/angular/angular/issues/7794)
+* **common/datePipe:** change date formatter to use correct pattern closes #7008 (#8154) ([324f014](https://github.com/angular/angular/commit/324f014)), closes [#7008](https://github.com/angular/angular/issues/7008) [(#8154](https://github.com/(/issues/8154)
+* **compiler:** Add support for limited function calls in metadata ([5504ca1](https://github.com/angular/angular/commit/5504ca1e389f7bfd74604b8573ddaab3e9f07b0d))
+* **compiler:** Add support for `<ng-container>` ([0dbff55](https://github.com/angular/angular/commit/0dbff55bc6750653c5f8decc06d07e7269e3d6a5))
+* **ComponentResolver:** Add a SystemJS resolver for compiled apps (#9145) ([a6e5ddc](https://github.com/angular/angular/commit/a6e5ddc))
+* **core:** add a component resolver that can load components lazily using system.js ([1a0aea6](https://github.com/angular/angular/commit/1a0aea6))
+* **core:** introduce support for animations ([5e0f8cf](https://github.com/angular/angular/commit/5e0f8cf)), closes [#8734](https://github.com/angular/angular/issues/8734)
+* **core/linker:** add SimpleChanges type to lifecycle_hooks to simplify OnChanges signature ([0a872ff](https://github.com/angular/angular/commit/0a872ff)), closes [#8557](https://github.com/angular/angular/issues/8557)
+* **debug:** collect styles and classes for the DebugElement ([155b882](https://github.com/angular/angular/commit/155b882))
+* **enableDebugTools:** return ComponentRef ([4086b49](https://github.com/angular/angular/commit/4086b49))
+* **forms:** add new forms folder ([4c39eac](https://github.com/angular/angular/commit/4c39eac))
+* **forms:** add the submitted flag to NgForm and NgFormModel directives ([420e83a](https://github.com/angular/angular/commit/420e83a)), closes [#2960](https://github.com/angular/angular/issues/2960) [#7449](https://github.com/angular/angular/issues/7449)
+* **forms:** allow ngModel to register with parent form ([4ed6cf7](https://github.com/angular/angular/commit/4ed6cf7))
+* **forms:** compose validator fns automatically if arrays ([61960c5](https://github.com/angular/angular/commit/61960c51a3b21d1cfba523f53016f6284182d4e3))
+* **forms:** support setting control name in ngModelOptions ([a191e96](https://github.com/angular/angular/commit/a191e9697c32062eda06cd1f1cfd856d89c16026))
+* **forms:** add easy way to switch between forms modules ([22916bb](https://github.com/angular/angular/commit/22916bb5d1abf2818d7d8d99d39605af251f42e4))
+* **HtmlLexer:** add support for alphabetic cases ([43148d8](https://github.com/angular/angular/commit/43148d8))
+* **http:** added withCredentials support ([95af14b](https://github.com/angular/angular/commit/95af14b)), closes [#7281](https://github.com/angular/angular/issues/7281) [#7281](https://github.com/angular/angular/issues/7281)
+* **http:** automatically set request Content-Type header based on body type ([0f0a8ad](https://github.com/angular/angular/commit/0f0a8ad)), closes [#7310](https://github.com/angular/angular/issues/7310)
+* **http:** implement Response.prototype.toString() to make for a nicer error message ([89f6108](https://github.com/angular/angular/commit/89f6108)), closes [#7511](https://github.com/angular/angular/issues/7511)
+* **http:** set the statusText property from the XMLHttpRequest instance ([3019140](https://github.com/angular/angular/commit/3019140)), closes [#4162](https://github.com/angular/angular/issues/4162)
+* **i18n:** extract messages ([ac11567](https://github.com/angular/angular/commit/ac11567))
+* **i18n:** support implicit tags/attributes ([3e5716e](https://github.com/angular/angular/commit/3e5716e))
+* **i18n:** generate error on unknown cases ([5267115](https://github.com/angular/angular/commit/5267115)), closes [#9094](https://github.com/angular/angular/issues/9094)
+* **i18n:** Add file paths to error messages ([fe01e2e](https://github.com/angular/angular/commit/fe01e2efb7e21ed0331e403a7508ac7fca946108))
+* **metadata:** emit all methods ([29700aa](https://github.com/angular/angular/commit/29700aa))
+* **NgTemplateOutlet:** add context to NgTemplateOutlet ([164a091](https://github.com/angular/angular/commit/164a091)), closes [#9042](https://github.com/angular/angular/issues/9042)
+* **NgZone:** isStable ([587c119](https://github.com/angular/angular/commit/587c119)), closes [#8108](https://github.com/angular/angular/issues/8108)
+* **platform-browser-dynamic:** re-add a deprecated platform-browser-dynamic ([172a566](https://github.com/angular/angular/commit/172a566))
+* **platform-browser-dynamic:** fix public exports for web-worker related symbols ([6e62217](https://github.com/angular/angular/commit/6e62217))
+* **regex_url_paths:** add `regex_group_names` to handle consistency with serializers ([ce013a3](https://github.com/angular/angular/commit/ce013a3)), closes [#7554](https://github.com/angular/angular/issues/7554) [#7694](https://github.com/angular/angular/issues/7694)
+* **renderer:** add a `setElementStyles` method ([1ac38bd](https://github.com/angular/angular/commit/1ac38bd))
+* **router:** export RouterLink and RouterOutlet (#8912) ([1c92903](https://github.com/angular/angular/commit/1c92903))
+* **router:** update router to support lazy loading ([0f1465b](https://github.com/angular/angular/commit/0f1465b))
+* **SchemaRegistry:** add Node.textContent ([3b80ab5](https://github.com/angular/angular/commit/3b80ab5)), closes [#8413](https://github.com/angular/angular/issues/8413)
+* **security:** add an HTML sanitizer. ([f86edae](https://github.com/angular/angular/commit/f86edae))
+* **security:** add tests for style sanitisation. ([7b6c4d5](https://github.com/angular/angular/commit/7b6c4d5))
+* **security:** add tests for URL sanitization. ([7a524e3](https://github.com/angular/angular/commit/7a524e3))
+* **security:** allow data: URLs for images and videos. ([dd50124](https://github.com/angular/angular/commit/dd50124))
+* **security:** allow url(...) style values. ([15ae710](https://github.com/angular/angular/commit/15ae710)), closes [#8514](https://github.com/angular/angular/issues/8514)
+* **security:** Automatic XSRF handling. ([4d793c4](https://github.com/angular/angular/commit/4d793c4))
+* **security:** complete DOM security schema. ([040b101](https://github.com/angular/angular/commit/040b101))
+* **security:** document iframe src to be TRUSTED_URL. ([3463047](https://github.com/angular/angular/commit/3463047))
+* add minified bundles ([9175a04](https://github.com/angular/angular/commit/9175a04))
+* **security:** expose the safe value types. ([50c9bed](https://github.com/angular/angular/commit/50c9bed)), closes [#8568](https://github.com/angular/angular/issues/8568)
+* **security:** fill in missing security contexts. ([67ed2e2](https://github.com/angular/angular/commit/67ed2e2))
+* **security:** strip XSSI prefix from XHR responses. ([df1b1f6](https://github.com/angular/angular/commit/df1b1f6))
+* **security:** support transform CSS functions for sanitization. ([8b1b427](https://github.com/angular/angular/commit/8b1b427)), closes [#8514](https://github.com/angular/angular/issues/8514)
+* **security:** warn users when sanitizing in dev mode. ([3e68b7e](https://github.com/angular/angular/commit/3e68b7e)), closes [#8522](https://github.com/angular/angular/issues/8522)
+* **shadow_css:** add encapsulation support for CSS @supports at-rule ([cb84cbf](https://github.com/angular/angular/commit/cb84cbf)), closes [#7944](https://github.com/angular/angular/issues/7944)
+* **ViewEncapsulation:** default ViewEncapsulation to configurable ([f93512b](https://github.com/angular/angular/commit/f93512b)), closes [#7883](https://github.com/angular/angular/issues/7883)
+
+
+### BREAKING CHANGES
+* Location#platformStrategy property was previously accidentally exported as public
+If any application requires access to the current location strategy, it should be accessed via DI instead
+by injecting the LocationStrategy token.
+The likelihood of anyone actually depending on this property is very low.
+
+* DirectiveNormalizer takes new constructor arguments, `config:CompilerConfig`.
+
+* `Parser` constructor required new parameter `config: CompilerConfig` as second argument.
+
+* Bundles are now in the bundles/ subdirectory within each package
+
+* HTML, style values, and URLs are now automatically sanitized. Values that do not match are escaped
+  or ignored. When binding a URL or style property that would get ignored, bind to a value
+  explicitly marked as safe instead by injection the DOM sanitization service:
+  
+  ```
+  class MyComponent {
+    constructor(sanitizer: DomSanitizationService) {
+      // ONLY DO THIS FOR VALUES YOU KNOW TO BE SAFE! NEVER ALLOW USER DATA IN THIS!
+      this.safeStyleValue = sanitizer.bypassSecurityTrustStyle('rotate(90deg)');
+      // then bind to `safeStyleValue` in your template.
+    }
+  }
+  ```
+
+* `PLATFORM_PIPES` and `PLATFORM_DIRECTIVES` now are fields on `CompilerConfig`. 
+  Instead of providing a binding to these tokens, provide a binding for `CompilerConfig` instead.
+
+* `CompilerConfig` used to take positional arguments and now takes named arguments.
+
+### Deprecation
+
+* `Parse5DomAdapter` will no longer be exported from `@angular/platform-server` as a public API as of RC.3.
+  A new function called `serverBootstrap()` will be provided, which will automatically set the correct
+  `document` during platform initialization.
+
+### Reverts
+
+* Revert fix(compiler): support string tokens with `.` inside. ([cc86fee](https://github.com/angular/angular/commit/cc86fee))
+
+<a name="2.0.0-rc.1"></a>
+# 2.0.0-rc.1 (2016-05-03)
+
+### Known Issues
+
+*** SECURITY WARNING ***
+Contextual escaping is not yet implemented in Angular 2. This will be fixed in the upcoming RC.
+In the meantime make sure to correctly escape all values that go into the DOM.
+*** SECURITY WARNING ***
+
+- source maps for umd bundles are missing
+- `Ruler` service is not being reexported via `@angular/platform-browser`
+
+
+### Bug Fixes
+
+* **compiler:** calculate the right moduleUrl ([3a40cb1](https://github.com/angular/angular/commit/3a40cb1))
+* **compiler:** don’t emit metadata for generated files ([43e0fa5](https://github.com/angular/angular/commit/43e0fa5))
+* **compiler:** fix where pipes live ([dd6e0cf](https://github.com/angular/angular/commit/dd6e0cf)), closes [#8408](https://github.com/angular/angular/issues/8408)
+* **compiler:** use absolute paths for comparing module urls ([52a6ba7](https://github.com/angular/angular/commit/52a6ba7))
+* **compiler:** use rootDirs compilerOption to affect genDir layout. ([a033f83](https://github.com/angular/angular/commit/a033f83))
+* **docs:** upgrade deprecated ngFor-Syntax ([27a7b51](https://github.com/angular/angular/commit/27a7b51))
+* **router:** add support for ../ ([89704e0](https://github.com/angular/angular/commit/89704e0))
+* **testing:** Check for pending macrotasks in ComponentFixture.whenStable() and ComponentFixtu ([509f4ec](https://github.com/angular/angular/commit/509f4ec)), closes [#8389](https://github.com/angular/angular/issues/8389)
+* **router-deprecated:** inheriting from RouterOutlet works now
+
+### Features
+
+* **router:** make RouterLink accept single values ([b625f24](https://github.com/angular/angular/commit/b625f24))
+
+
+
+<a name="2.0.0-rc.0"></a>
+# 2.0.0-rc.0 (2016-05-02)
+
+This is the first release candidate that contains repackaging of Angular into individual packages one per each feature area.
+
+All of the packages are now distributed under the @angular npm scope. This changes how Angular is installed via npm and how you import the code.
+
+To install Angular for a browser application please use:
+
+```
+npm install --save @angular/core @angular/compiler @angular/common @angular/platform-browser @angular/platform-browser-dynamic rxjs@5.0.0-beta.6 zone.js@0.6.12
+```
+
+To import various symbols please adjust the paths in the following way:
+
+- `angular2/core` -> `@angular/core`
+- `angular2/compiler` -> `@angular/compiler`
+- `angular2/common` -> `@angular/common`
+- `angular2/platform/browser` -> `@angular/platform-browser` (applications with precompiled templates) + `@angular/platform-browser-dynamic` (applications that compile templates on the fly)
+- `angular2/platform/server` -> `@angular/platform-server`
+- `angular2/testing` -> `@angular/core/testing` (it/describe/..) + `@angular/compiler/testing` (TestComponentBuilder) + `@angular/platform-browser/testing`
+- `angular2/upgrade` -> `@angular/upgrade`
+- `angular2/http` -> `@angular/http`
+- `angular2/router` -> `@angular/router-deprecated` (snapshot of the component router from beta.17 for backwards compatibility)
+- new package: `@angular/router` - component router with several [breaking changes](https://docs.google.com/document/d/1WLSNV3V1AKdwLwRiLuN7JqbPBKQ_S5quRlcT5LPIldw/edit#heading=h.blfh5ya9sf5r)
+
+
+
+### Features
+
+* **core:** introduce template context ([cacdead](https://github.com/angular/angular/commit/cacdead)), closes [#8321](https://github.com/angular/angular/issues/8321)
+* **core:** support the decorator data that tsickle produces ([b6fd811](https://github.com/angular/angular/commit/b6fd811))
+* **di:** support map literals as providers ([46cd868](https://github.com/angular/angular/commit/46cd868))
+* **offline compiler:** a replacement for tsc that compiles templates ([78946fe](https://github.com/angular/angular/commit/78946fe))
+* **offline compiler:** add metadata emit ([072446a](https://github.com/angular/angular/commit/072446a))
+* **router:** add CanDeactivate ([deba804](https://github.com/angular/angular/commit/deba804))
+* **router:** add link that support only absolute urls ([fa5bfe4](https://github.com/angular/angular/commit/fa5bfe4))
+* **router:** add Router and RouterOutlet to support aux routes ([6e1fed4](https://github.com/angular/angular/commit/6e1fed4))
+* **router:** add RouterLink ([de56dd5](https://github.com/angular/angular/commit/de56dd5))
+* **router:** add RouterUrlSerializer ([79830f1](https://github.com/angular/angular/commit/79830f1))
+* **router:** add RouteTree and UrlTree as aliases to Tree<RouteSegment> and Tree<UrlSegment> ([277b1fc](https://github.com/angular/angular/commit/277b1fc))
+* **router:** add support for wildcards ([8836219](https://github.com/angular/angular/commit/8836219))
+* **router:** adds an example app using the new router ([602641d](https://github.com/angular/angular/commit/602641d))
+* **router:** change location when navigating ([560cc14](https://github.com/angular/angular/commit/560cc14))
+* **router:** implement relative navigation ([e5b87e5](https://github.com/angular/angular/commit/e5b87e5))
+* **router:** implements support for router-link-active ([ec4ca0e](https://github.com/angular/angular/commit/ec4ca0e))
+* **router:** listen to location changes ([62a0809](https://github.com/angular/angular/commit/62a0809)), closes [#8362](https://github.com/angular/angular/issues/8362)
+* **router:** set router-link-active when RouterLink is active ([4fe0f1f](https://github.com/angular/angular/commit/4fe0f1f)), closes [#8376](https://github.com/angular/angular/issues/8376)
+* **router:** update recognize to handle matrix parameters ([446657b](https://github.com/angular/angular/commit/446657b))
+* **router:** update recognize to support aux routes ([d35c109](https://github.com/angular/angular/commit/d35c109))
+* **router:** update url parser to handle aux routes ([fad3b64](https://github.com/angular/angular/commit/fad3b64))
+* **testing:** Use NgZone in TestComponentBuilder. ([769835e](https://github.com/angular/angular/commit/769835e)), closes [#8301](https://github.com/angular/angular/issues/8301)
+* **tests:** add ROUTER_FAKE_PROVIDERS to angular2/alt_router/router_testing_providers ([0f1b370](https://github.com/angular/angular/commit/0f1b370))
+
+### Bug Fixes
+
+* **metadata:** Preserve Provider expressions ([7c0d497](https://github.com/angular/angular/commit/7c0d497))
+* **codegen:** event handler has boolean return type ([ca40ef5](https://github.com/angular/angular/commit/ca40ef5))
+* **compiler:** fix cross view references and providers with `useValue`. ([f114d6c](https://github.com/angular/angular/commit/f114d6c)), closes [#8366](https://github.com/angular/angular/issues/8366)
+* **compiler:** project using the right directive as component. ([0f774df](https://github.com/angular/angular/commit/0f774df)), closes [#8344](https://github.com/angular/angular/issues/8344)
+* **compiler:** support css stylesheets in offline compiler ([00d3b60](https://github.com/angular/angular/commit/00d3b60))
+* **compiler:** support empty array and map literals. ([11955f9](https://github.com/angular/angular/commit/11955f9)), closes [#8336](https://github.com/angular/angular/issues/8336)
+* **compiler_cli:** make sure the generated code gets compiled via tic ([163d80a](https://github.com/angular/angular/commit/163d80a))
+* **core:** check components if an event handler inside of an embedded view fires. ([4d691b6](https://github.com/angular/angular/commit/4d691b6)), closes [#8242](https://github.com/angular/angular/issues/8242)
+* **core:** return the ChangeDetectorRef of the component also for embedded views. ([351f24e](https://github.com/angular/angular/commit/351f24e))
+* **metadata:** expose Providers in metadata ([8bf6ef6](https://github.com/angular/angular/commit/8bf6ef6))
+* **perf:** don’t use `try/catch` in production mode ([b1a9e44](https://github.com/angular/angular/commit/b1a9e44)), closes [#8338](https://github.com/angular/angular/issues/8338)
+* **router:** canDeactivate should not change the url when returns false ([76d6f5f](https://github.com/angular/angular/commit/76d6f5f)), closes [#8360](https://github.com/angular/angular/issues/8360)
+* **router:** create a route tree when creating the router service ([ca13f1c](https://github.com/angular/angular/commit/ca13f1c)), closes [#8365](https://github.com/angular/angular/issues/8365)
+* **typescript:** strip abstract keyword from properties in .d.ts ([a84c2d7](https://github.com/angular/angular/commit/a84c2d7)), closes [#8339](https://github.com/angular/angular/issues/8339)
+
+
+
+### OTHER BREAKING CHANGES
+
+
+* - ViewRef.changeDetectorRef was removed as using ChangeDetectorRefs
+  for EmbeddedViewRefs does not make sense. Use ComponentRef.changeDetectorRef
+  or inject ChangeDetectorRef instead.
+
+* - Before, a `EmbeddedViewRef` used to have methods for
+  setting variables. Now, a user has to pass in a context
+  object that represents all variables when an `EmbeddedViewRef`
+  should be created.
+- `ViewContainerRef.createEmbeddedViewRef` now takes
+   a context object as 2nd argument.
+- `EmbeddedViewRef.setLocal` and `getLocal` have been removed.
+  Use `EmbeddedViewRef.context` to access the context.
+- `DebugNode.locals` has been removed. Use the new methods `DebugElement.references`
+  to get the references that are present on this element,
+  or `DebugElement.context` to get the context of the `EmbeddedViewRef` or the component to which the element belongs.
+* - Depending on if you are using precompiled templates or you are compiling templates on the fly, the setup for the base test providers has changed:
+
+Before:
+```js
+// Somewhere in test setup
+import {setBaseTestProviders} from 'angular2/testing';
+import {
+  TEST_BROWSER_PLATFORM_PROVIDERS,
+  TEST_BROWSER_APPLICATION_PROVIDERS
+} from 'angular2/platform/testing/browser';
+setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
+                     TEST_BROWSER_APPLICATION_PROVIDERS);
+```
+After (applications that compile templates on the fly):
+```js
+// Somewhere in the test setup
+import {setBaseTestProviders} from '@angular/core/testing';
+import {
+  TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS,
+  TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS
+} from '@angular/platform-browser-dynamic/testing';
+setBaseTestProviders(TEST_BROWSER_DYNAMIC_PLATFORM_PROVIDERS,
+                     TEST_BROWSER_DYNAMIC_APPLICATION_PROVIDERS);
+```
+
+After (applications with precompiled templates):
+```js
+// Somewhere in the test setup
+import {setBaseTestProviders} from '@angular/core/testing';
+import {
+  TEST_BROWSER_STATIC_PLATFORM_PROVIDERS,
+  TEST_BROWSER_STATIC_APPLICATION_PROVIDERS
+} from '@angular/platform-browser/testing';
+setBaseTestProviders(TEST_BROWSER_STATIC_PLATFORM_PROVIDERS,
+                     TEST_BROWSER_STATIC_APPLICATION_PROVIDERS);
+```
+
+
+<a name="2.0.0-beta.17"></a>
+# 2.0.0-beta.17 (2016-04-28)
+
+
+### Bug Fixes
+
+* **changelog:** fix changelog script. ([c209836](https://github.com/angular/angular/commit/c209836))
+* **compiler:** Allow templates to access variables that are declared afterwards. ([1e8864c](https://github.com/angular/angular/commit/1e8864c)), closes [#8261](https://github.com/angular/angular/issues/8261)
+* **core:** properly evaluate expressions with conditional and boolean operators ([1ad2a02](https://github.com/angular/angular/commit/1ad2a02)), closes [#8235](https://github.com/angular/angular/issues/8235) [#8244](https://github.com/angular/angular/issues/8244) [#8282](https://github.com/angular/angular/issues/8282)
+* **metadata:** Do not attach module names to metadata. ([d964888](https://github.com/angular/angular/commit/d964888)), closes [#8225](https://github.com/angular/angular/issues/8225) [#8082](https://github.com/angular/angular/issues/8082) [#8256](https://github.com/angular/angular/issues/8256)
+* **testing:** allow test component builder to override directives from lists ([ff2ae7a](https://github.com/angular/angular/commit/ff2ae7a)), closes [#7397](https://github.com/angular/angular/issues/7397) [#8217](https://github.com/angular/angular/issues/8217)
+
+### Features
+
+* **compiler:** ElementSchema now has explicit DOM schema information ([d327ac4](https://github.com/angular/angular/commit/d327ac4)), closes [#8179](https://github.com/angular/angular/issues/8179)
+* **core:** separate refs from vars. ([d2efac1](https://github.com/angular/angular/commit/d2efac1)), closes [#7158](https://github.com/angular/angular/issues/7158) [#8264](https://github.com/angular/angular/issues/8264)
+
+
+### BREAKING CHANGES
+
+The reference `#...` now always means `ref-`.
+
+**Before:**
+- Outside of `ngFor`, a `#...` meant a reference.
+- Inside of `ngFor`, it meant a local variable.
+
+This pattern was confusing.
+
+**After:**
+
+- `<template #abc>` now defines a reference to a TemplateRef, instead of an input variable used inside of the template.
+- Inside of structural directives that declare local variables, such as `*ngFor`, usage of `#...` is deprecated. Use `let` instead.
+  - `<div *ngFor="#item of items">` now becomes `<div *ngFor="let item of items">`
+- `var-...` is deprecated.
+  - use `#` or a `ref-` outside of `*ngFor`
+  - for `ngFor`, use the syntax:  `<template ngFor let-... [ngForOf]="...">`
+
+
+<a name="2.0.0-beta.16"></a>
+# 2.0.0-beta.16 (2016-04-26)
+
+
+### Bug Fixes
+
+* **angular_1_router:** Removed arrow function from module template ([d094a85](https://github.com/angular/angular/commit/d094a85)), closes [#8076](https://github.com/angular/angular/issues/8076)
+* **build:** ignore Dart warnings for external code. ([4140405](https://github.com/angular/angular/commit/4140405))
+* **codegen:** add explicit any to class fields ([c8d00dc](https://github.com/angular/angular/commit/c8d00dc)), closes [#8204](https://github.com/angular/angular/issues/8204) [#8205](https://github.com/angular/angular/issues/8205)
+* **compiler:** only call pure pipes if their input changed. ([8db6215](https://github.com/angular/angular/commit/8db6215))
+* **compiler:** properly implement pure pipes and change pipe syntax ([152a117](https://github.com/angular/angular/commit/152a117))
+* **compiler:** support string tokens with `.` inside. ([cc86fee](https://github.com/angular/angular/commit/cc86fee))
+* **compiler:** use DI order for change detection order. ([67d05eb](https://github.com/angular/angular/commit/67d05eb)), closes [#8198](https://github.com/angular/angular/issues/8198)
+* **core:** various minor compiler fixes ([2f70457](https://github.com/angular/angular/commit/2f70457)), closes [#8162](https://github.com/angular/angular/issues/8162)
+* **forms:** ensure select model updates in firefox and ie ([c3daccd](https://github.com/angular/angular/commit/c3daccd)), closes [#6573](https://github.com/angular/angular/issues/6573) [#8148](https://github.com/angular/angular/issues/8148)
+* **forms:** improve error message when ngFormModel is missing a form ([12837e1](https://github.com/angular/angular/commit/12837e1)), closes [#8136](https://github.com/angular/angular/issues/8136) [#8143](https://github.com/angular/angular/issues/8143)
+* **forms:** number input should report null when blank ([e69cb40](https://github.com/angular/angular/commit/e69cb40)), closes [#6932](https://github.com/angular/angular/issues/6932) [#8141](https://github.com/angular/angular/issues/8141)
+* **metadata:** emit metadata rooted at 'angular2' ([9889c21](https://github.com/angular/angular/commit/9889c21)), closes [#8144](https://github.com/angular/angular/issues/8144) [#8147](https://github.com/angular/angular/issues/8147)
+* **release:** Fix the package.json zone.js requirement to 0.6.12 ([6103aa0](https://github.com/angular/angular/commit/6103aa0))
+* **tests:** remove payload size check ([22c05b0](https://github.com/angular/angular/commit/22c05b0))
+* **transformers:** support `query.read` ([386cc5d](https://github.com/angular/angular/commit/386cc5d)), closes [#8172](https://github.com/angular/angular/issues/8172)
+* **upgrade:** clean up scope when element is destroyed ([0fc9ec2](https://github.com/angular/angular/commit/0fc9ec2)), closes [#8102](https://github.com/angular/angular/issues/8102)
+
+### Features
+
+* **codegen:** produce `.ngfactory.dart/ts` files instead of `.template.dart/ts` files. ([c06b0a2](https://github.com/angular/angular/commit/c06b0a2))
+* **core:** add `Query.read` and remove `DynamicComponentLoader.loadIntoLocation`. ([efbd446](https://github.com/angular/angular/commit/efbd446))
+* **core:** introduce ComponentFactory. ([0c600cf](https://github.com/angular/angular/commit/0c600cf))
+* **core:** separate reflective injector from Injector interface ([0a7d10b](https://github.com/angular/angular/commit/0a7d10b))
+* **core:** support importUri in StaticReflector ([3e11422](https://github.com/angular/angular/commit/3e11422)), closes [#8195](https://github.com/angular/angular/issues/8195)
+* **core:** support non reflective bootstrap. ([9092ac7](https://github.com/angular/angular/commit/9092ac7))
+* **html_lexer:** support special forms used by i18n { exp, plural, =0 {} } ([7f29766](https://github.com/angular/angular/commit/7f29766))
+* **html_parser:** support special forms used by i18n { exp, plural, =0 {} } ([7c9717b](https://github.com/angular/angular/commit/7c9717b))
+* **i18n:** add custom placeholder names ([bb9fb21](https://github.com/angular/angular/commit/bb9fb21)), closes [#7799](https://github.com/angular/angular/issues/7799) [#8057](https://github.com/angular/angular/issues/8057)
+* **i18n:** add support for nested expansion forms ([c6244d1](https://github.com/angular/angular/commit/c6244d1)), closes [#7977](https://github.com/angular/angular/issues/7977)
+* **i18n:** support plural and gender special forms ([88b0a23](https://github.com/angular/angular/commit/88b0a23))
+* **Location:** out of router and into platform/common ([b602bd8](https://github.com/angular/angular/commit/b602bd8)), closes [#7962](https://github.com/angular/angular/issues/7962)
+* **NgTemplateOutlet:** add NgTemplateOutlet directive ([f4e6994](https://github.com/angular/angular/commit/f4e6994)), closes [#7615](https://github.com/angular/angular/issues/7615) [#8021](https://github.com/angular/angular/issues/8021)
+* **router:** add Router and RouterOutlet ([5a897cf](https://github.com/angular/angular/commit/5a897cf)), closes [#8173](https://github.com/angular/angular/issues/8173)
+* **router:** add router metadata ([ef67a0c](https://github.com/angular/angular/commit/ef67a0c))
+* **router:** add UrlSegment, RouteSegment, and Tree ([90a1f7d](https://github.com/angular/angular/commit/90a1f7d))
+* **router:** implement recognizer ([ef6163e](https://github.com/angular/angular/commit/ef6163e))
+* **router:** implement RouterUrlParser ([f698567](https://github.com/angular/angular/commit/f698567))
+* **test:** Implement fakeAsync using the FakeAsyncTestZoneSpec from zone.js. ([bab81a9](https://github.com/angular/angular/commit/bab81a9)), closes [#8142](https://github.com/angular/angular/issues/8142)
+* **tests:** manage asynchronous tests using zones ([8490921](https://github.com/angular/angular/commit/8490921)), closes [#7735](https://github.com/angular/angular/issues/7735)
+* **view_compiler:** codegen DI and Queries ([2b34c88](https://github.com/angular/angular/commit/2b34c88)), closes [#6301](https://github.com/angular/angular/issues/6301) [#6567](https://github.com/angular/angular/issues/6567)
+
+
+### BREAKING CHANGES
+
+* - pipes now take a variable number of arguments, and not an array that contains all arguments.
+
+* inject can no longer wrap fakeAsync while fakeAsync can wrap inject. So the order in existing tests with inject and fakeAsync has to be switched as follows:
+Before:
+```
+inject([...], fakeAsync((...) => {...}))
+```
+After:
+```
+fakeAsync(inject([...], (...) => {...}))
+```
+You will also need to add the dependency
+`'node_modules/zone.js/dist/fake-async-test.js'`
+as a served file in your Karma or other test configuration.
+
+* - Injector was renamed into `ReflectiveInjector`,
+  as `Injector` is only an abstract class with one method on it
+- `Injector.getOptional()` was changed into `Injector.get(token, notFoundValue)`
+  to make implementing injectors simpler
+- `ViewContainerRef.createComponent` now takes an `Injector`
+  instead of `ResolvedProviders`. If a reflective injector
+  should be used, create one before calling this method.
+  (e.g. via `ReflectiveInjector.resolveAndCreate(…)`.
+
+* - `DynamicComponentLoader.loadIntoLocation` has been removed. Use `@ViewChild(‘myVar’, {read: ViewContainerRef})` to get hold of a `ViewContainerRef` at an element with variable `myVar`. Then call `DynamicComponentLoader.loadNextToLocation`.
+- `DynamicComponentLoader.loadNextToLocation` now takes a `ViewContainerRef` instead of an `ElementRef`.
+- `AppViewManager` is renamed into `ViewUtils` and is a mere private utility service.
+
+* - `Compiler` is renamed to `ComponentResolver`,
+  `Compiler.compileInHost` has been renamed to `ComponentResolver.resolveComponent`.
+- `ComponentRef.dispose` is renamed to `ComponentRef.destroy`
+- `ViewContainerRef.createHostView` is renamed to `ViewContainerRef.createComponent`
+- `ComponentFixture_` has been removed, the class `ComponentFixture`
+  can now be created directly as it is no more using private APIs.
+
+* `Location` and other related providers have been moved out of `router` and into `platform/common`. `BrowserPlatformLocation` is not meant to be used directly however advanced configurations may use it via the following import change.
+Before:
+```
+import {
+  PlatformLocation,
+  Location,
+  LocationStrategy,
+  HashLocationStrategy,
+  PathLocationStrategy,
+  APP_BASE_HREF}
+from 'angular2/router';
+import {BrowserPlatformLocation} from 'angular2/src/router/location/browser_platform_location';
+```
+After:
+```
+import {
+  PlatformLocation,
+  Location,
+  LocationStrategy,
+  HashLocationStrategy,
+  PathLocationStrategy,
+  APP_BASE_HREF}
+from 'angular2/platform/common';
+import {BrowserPlatformLocation} from 'angular2/src/platform/browser/location/browser_platform_location';
+```
+
+* `injectAsync` is now deprecated. Instead, use the `async` function
+to wrap any asynchronous tests.
+
+You will also need to add the dependency
+`'node_modules/zone.js/dist/async-test.js'`
+as a served file in your Karma or other test configuration.
+
+Before:
+```
+it('should wait for returned promises', injectAsync([FancyService], (service) => {
+  return service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
+}));
+it('should wait for returned promises', injectAsync([], () => {
+  return somePromise.then(() => { expect(true).toEqual(true); });
+}));
+```
+After:
+```
+it('should wait for returned promises', async(inject([FancyService], (service) => {
+  service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
+})));
+// Note that if there is no injection, we no longer need `inject` OR `injectAsync`.
+it('should wait for returned promises', async(() => {
+  somePromise.then(() => { expect(true).toEqual(true); });
+}));
+```
+
+* - Renderer:
+  * renderComponent method is removed form `Renderer`, only present on `RootRenderer`
+  * Renderer.setDebugInfo is removed. Renderer.createElement / createText / createTemplateAnchor
+    now take the DebugInfo directly.
+- Query semantics:
+  * Queries don't work with dynamically loaded components.
+  * e.g. for router-outlet: loaded components can't be queries via @ViewQuery,
+    but router-outlet emits an event `activate` now that emits the activated component
+- Exception classes and the context inside changed (renamed fields)
+- DebugElement.attributes is an Object and not a Map in JS any more
+- ChangeDetectorGenConfig was renamed into CompilerConfig
+- AppViewManager.createEmbeddedViewInContainer / AppViewManager.createHostViewInContainer
+  are removed, use the methods in ViewContainerRef instead
+- Change detection order changed:
+  * 1. dirty check component inputs
+  * 2. dirty check content children
+  * 3. update render nodes
+
+
+
+<a name="2.0.0-beta.15"></a>
+# 2.0.0-beta.15 (2016-04-13)
+
+
+### Bug Fixes
+
+* **7837:** MetadataCollector takes no parameters for the constructor. ([c17dc1c](https://github.com/angular/angular/commit/c17dc1c)), closes [#7838](https://github.com/angular/angular/issues/7838)
+* **7987:** Incremental build works with new trees ([08b2956](https://github.com/angular/angular/commit/08b2956)), closes [#7989](https://github.com/angular/angular/issues/7989)
+* **build:** ignore dart warnings `The name … is shown, but not used` ([01e6b8c](https://github.com/angular/angular/commit/01e6b8c)), closes [#8045](https://github.com/angular/angular/issues/8045)
+* **payload:** increase payload size limit temporarily ([28e657d](https://github.com/angular/angular/commit/28e657d))
+* **RouterLink:** ignore optional parameters when checking for active routes ([5e2bc5c](https://github.com/angular/angular/commit/5e2bc5c)), closes [#6459](https://github.com/angular/angular/issues/6459) [#7834](https://github.com/angular/angular/issues/7834)
+* **select:** set value individually from ngModel ([e1e44a9](https://github.com/angular/angular/commit/e1e44a9)), closes [#7975](https://github.com/angular/angular/issues/7975) [#7978](https://github.com/angular/angular/issues/7978)
+* **upgrade:** make upgradeAdapter upgrade angular 1 components correctly ([247964a](https://github.com/angular/angular/commit/247964a)), closes [#7951](https://github.com/angular/angular/issues/7951)
+
+### Features
+
+* **compiler:** Add an implementation for XHR that uses a template cache to load template files. ([a596b88](https://github.com/angular/angular/commit/a596b88)), closes [#7940](https://github.com/angular/angular/issues/7940)
+* **gestures:** allow override of Hammer default configuration ([6cbf990](https://github.com/angular/angular/commit/6cbf990)), closes [#7924](https://github.com/angular/angular/issues/7924)
+* **ngFor:** Support convenience  view local in ngFor ([ccff175](https://github.com/angular/angular/commit/ccff175)), closes [#8013](https://github.com/angular/angular/issues/8013)
+* **parser:** TemplateParser.tryParse() returns both the AST and errors ([226e662](https://github.com/angular/angular/commit/226e662)), closes [#7858](https://github.com/angular/angular/issues/7858)
+* **transformers:** changes transformers to collect information about providers and resolve identifi ([3b60503](https://github.com/angular/angular/commit/3b60503))
+* **transformers:** special case Profiler ([83b8f59](https://github.com/angular/angular/commit/83b8f59))
+* **typescript:** update to 1.9 nightly. ([3412aba](https://github.com/angular/angular/commit/3412aba)), closes [#8003](https://github.com/angular/angular/issues/8003)
+
+### BREAKING CHANGES
+
+* In Dart files, `import 'package:angular2/bootstrap.dart'` no longer works.
+  Instead, use `import 'package:angular2/platform/browser.dart'`.
+
+### Reverts
+
+* Revert "chore(format): update to latest formatter" ([60727c4](https://github.com/angular/angular/commit/60727c4))
+
+
+
+<a name="2.0.0-beta.14"></a>
+# 2.0.0-beta.14 (2016-04-07)
+
+
+### Bug Fixes
+
+* **forms:** support both value and ng-value ([8db97b0](https://github.com/angular/angular/commit/8db97b0))
+* **router:** allow forward slashes in query parameters ([4902244](https://github.com/angular/angular/commit/4902244)), closes [#7824](https://github.com/angular/angular/issues/7824)
+* **select:** support objects as select values ([74e2bd7](https://github.com/angular/angular/commit/74e2bd7)), closes [#4843](https://github.com/angular/angular/issues/4843) [#7842](https://github.com/angular/angular/issues/7842)
+* **select:** update name from ng-value to ngValue ([3ca6df8](https://github.com/angular/angular/commit/3ca6df8)), closes [#7939](https://github.com/angular/angular/issues/7939)
+* **upgrade:** leak when angular1 destroys element ([9be04f8](https://github.com/angular/angular/commit/9be04f8)), closes [#6401](https://github.com/angular/angular/issues/6401) [#7935](https://github.com/angular/angular/issues/7935)
+
+### Features
+
+* **dart/transform:** Avoid `print` in transformer code. ([e310bee](https://github.com/angular/angular/commit/e310bee)), closes [#7855](https://github.com/angular/angular/issues/7855)
+* **static-reflector:** Added StaticReflector ([0dbf959](https://github.com/angular/angular/commit/0dbf959))
+
+
+
+
+
 <a name="2.0.0-beta.13"></a>
 # 2.0.0-beta.13 (2016-03-31)
 
@@ -30,14 +643,20 @@
 ### BREAKING CHANGES
 
 * For static content projection, elements with *-directives are now matched against the element itself vs the template before.
-    <p *ngIf="condition" foo></p>
+
+`<p *ngIf="condition" foo></p>`
+
 Before:
+```html
     // Use the implicit template for projection
     <ng-content select="template"></ng-content>
+```
+
 After:
+```html
     // Use the actual element for projection
     <ng-content select="p[foo]"></ng-content>
-
+```
 
 <a name="2.0.0-beta.12"></a>
 # 2.0.0-beta.12 (2016-03-23)
@@ -70,6 +689,10 @@ After:
 * **i18n:** create i18n barrel ([a7fe983](https://github.com/angular/angular/commit/a7fe983))
 * **i18n:** implement xmb serializer ([e1f8e54](https://github.com/angular/angular/commit/e1f8e54))
 
+### BREAKING CHANGES
+
+`@View()` annotation (previously deprecated) has been removed. Apps should use the `@Component()` decorator instead.
+
 
 <a name="2.0.0-beta.10"></a>
 # 2.0.0-beta.10 (2016-03-17)
@@ -148,18 +771,6 @@ is:
 }
 ```
 
-* The recently added binding of the current router to the current component
-has been renamed from `router` to `$router`.
-So now the recommended set up for your bindings in your routed component
-is:
-```js
-{
-  ...
-  bindings: {
-    $router: '<'
-  }
-}
-```
 
 
 
@@ -477,7 +1088,7 @@ setBaseTestProviders(TEST_BROWSER_PLATFORM_PROVIDERS,
   `platform_pipes`.
 * `Compiler.compileInHost` now returns a `HostViewFactoryRef`
 * Component view is not yet created when component constructor is called.
-  -> use `onInit` lifecycle callback to access the view of a component
+  -> use `ngOnInit` lifecycle callback to access the view of a component
 * `ViewRef#setLocal` has been moved to new type `EmbeddedViewRef`
 * `internalView` is gone, use `EmbeddedViewRef.rootNodes` to access
   the root nodes of an embedded view
@@ -755,7 +1366,7 @@ Use `angular-polyfills.js` instead.
   }
   ```
 
-  or [check angular2's package.json](https://github.com/angular/angular/blob/master/package.json#L34) for the latest peer dependencies
+  or [check angular2's package.json](https://github.com/angular/angular/blob/master/package.json) for the latest `dependencies`
 
 
 <a name="2.0.0-alpha.48"></a>

CONTRIBUTING.md

@@ -166,6 +166,19 @@ The **header** is mandatory and the **scope** of the header is optional.
 Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
 to read on GitHub as well as in various git tools.
 
+Footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
+
+Samples: (even more [samples](https://github.com/angular/angular/commits/master))
+
+```
+docs(changelog): update change log to beta.5
+```
+```
+fix(release): need to depend on latest rxjs and zone.js
+
+The version in our package.json gets copied to the one we publish, and users need the latest of these.
+```
+
 ### Revert
 If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.
 
@@ -225,8 +238,8 @@ changes to be accepted, the CLA must be signed. It's a quick process, we promise
 [github]: https://github.com/angular/angular
 [gitter]: https://gitter.im/angular/angular
 [individual-cla]: http://code.google.com/legal/individual-cla-v1.0.html
-[js-style-guide]: http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml
-[jsfiddle]: http://jsfiddle.net/
+[js-style-guide]: https://google.github.io/styleguide/javascriptguide.xml
+[jsfiddle]: http://jsfiddle.net
 [plunker]: http://plnkr.co/edit
-[runnable]: http://runnable.com/
+[runnable]: http://runnable.com
 [stackoverflow]: http://stackoverflow.com/questions/tagged/angular

DEVELOPER.md

@@ -32,17 +32,17 @@ following products on your development machine:
   (version `>=3.5.3 <4.0`), which comes with Node. Depending on your system, you can install Node either from
   source or as a pre-packaged bundle.
 
-* *Optional*: [Dart](https://www.dartlang.org) (version ` >=1.13.2 <2.0.0`), specifically the Dart-SDK and
+* *Optional*: [Dart](https://www.dartlang.org) (version `>=1.13.2 <2.0.0`), specifically the Dart SDK and
   Dartium (a version of [Chromium](http://www.chromium.org) with native support for Dart through
-  the Dart VM). One of the **simplest** ways to get both is to install the **Dart Editor bundle**,
-  which includes the editor, SDK and Dartium. See the [Dart tools](https://www.dartlang.org/tools)
-  download [page for instructions](https://www.dartlang.org/tools/download.html).  
-  You can also download both **stable** and **dev** channel versions from the [download
-  archive](https://www.dartlang.org/tools/download-archive). In that case, on Windows, Dart must be added
-  to the `Path` (e.g. `path-to-dart-sdk-folder\bin`) and a new `DARTIUM_BIN` environment variable must be
-  created, pointing to the executable (e.g. `path-to-dartium-folder\chrome.exe).`
-
+  the Dart VM). Visit Dart's [Downloads page](https://www.dartlang.org/downloads) page for
+  instructions. You can also download both **stable** and **dev** channel versions from the
+  [download archive](https://www.dartlang.org/downloads/archive/). In that case, on Windows, Dart
+  must be added to the `PATH` (e.g. `path-to-dart-sdk-folder\bin`) and a new `DARTIUM_BIN`
+  environment variable must be created, pointing to the executable (e.g.
+  `path-to-dartium-folder\chrome.exe`).
 
+* [Java Development Kit](http://www.oracle.com/technetwork/es/java/javase/downloads/index.html) which is used
+  to execute the selenium standalone server for e2e testing.
 
 ## Getting the Sources
 
@@ -183,8 +183,8 @@ Karma is run against the new output.
 much easier to debug. `xit` and `xdescribe` can also be useful to exclude a test and a group of
 tests respectively.
 
-**Note**: **watch mode** needs symlinks to work, so if you're using windows, ensure you have the
-rights to built them in your operating system.
+**Note**: **watch mode** needs symlinks to work, so if you're using Windows, ensure you have the
+rights to built them in your operating system. On Windows, only administrators can create symbolic links by default, but you may change the policy. (see [here](https://technet.microsoft.com/library/cc766301.aspx?f=255&MSPPError=-2147217396).)
 
 ### Unit tests with Sauce Labs or Browser Stack
 
@@ -238,17 +238,17 @@ repository, allowing many tools and editors to share our settings.
 
 To check the formatting of your code, run
 
-    gulp check-format
+    gulp lint
 
-Note that the continuous build on Travis runs `gulp enforce-format`. Unlike the `check-format` task,
-this will actually fail the build if files aren't formatted according to the style guide.
+Note that the continuous build on CircleCI will fail the build if files aren't formatted according
+to the style guide.
 
 Your life will be easier if you include the formatter in your standard workflow. Otherwise, you'll
 likely forget to check the formatting, and waste time waiting for a build on Travis that fails due
 to some whitespace difference.
 
-* Use `$(npm bin)/clang-format -i [file name]` to format a file (or multiple).
-* Use `gulp enforce-format` to check if your code is `clang-format` clean. This also gives
+* Use `gulp format` to format everything.
+* Use `gulp lint` to check if your code is `clang-format` clean. This also gives
   you a command line to format your code.
 * `clang-format` also includes a git hook, run `git clang-format` to format all files you
   touched.
@@ -256,10 +256,14 @@ to some whitespace difference.
   commit a change. In the angular repo, run
 
 ```
-    $ echo -e '#!/bin/sh\nexec git clang-format' > .git/hooks/pre-commit
+    $ echo -e '#!/bin/sh\nexec git clang-format --style file' > .git/hooks/pre-commit
     $ chmod u+x !$
 ```
 
+**NOTE**: To use ```git clang-format``` use have to make sure that ```git-clang-format``` is in your
+```PATH```. The easiest way is probably to just ```npm install -g clang-format``` as it comes with
+```git-clang-format```.
+
 * **WebStorm** can run clang-format on the current file.
   1. Under Preferences, open Tools > External Tools.
   1. Plus icon to Create Tool

README.md

@@ -1,9 +1,11 @@
 [![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular)
+[![CircleCI](https://circleci.com/gh/angular/angular/tree/master.svg?style=shield)](https://circleci.com/gh/angular/angular/tree/master)
 [![Join the chat at https://gitter.im/angular/angular](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/angular/angular?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Issue Stats](http://issuestats.com/github/angular/angular/badge/pr)](http://issuestats.com/github/angular/angular)
-[![Issue Stats](http://issuestats.com/github/angular/angular/badge/issue)](http://issuestats.com/github/angular/angular)
-[![npm version](https://badge.fury.io/js/angular2.svg)](http://badge.fury.io/js/angular2)
+[![Issue Stats](http://issuestats.com/github/angular/angular/badge/pr?style=flat)](http://issuestats.com/github/angular/angular)
+[![Issue Stats](http://issuestats.com/github/angular/angular/badge/issue?style=flat)](http://issuestats.com/github/angular/angular)
+[![npm version](https://badge.fury.io/js/%40angular%2Fcore.svg)](https://badge.fury.io/js/%40angular%2Fcore)
 [![Downloads](http://img.shields.io/npm/dm/angular2.svg)](https://npmjs.org/package/angular2)
+
 [![Sauce Test Status](https://saucelabs.com/browser-matrix/angular2-ci.svg)](https://saucelabs.com/u/angular2-ci)
 
 Angular
@@ -12,7 +14,7 @@ Angular
 Angular is a development platform for building mobile and desktop web applications. This is the
 repository for [Angular 2][ng2], both the JavaScript (JS) and [Dart][dart] versions.
 
-Angular 2 is currently in **Beta**. 
+Angular 2 is currently in **Release Candidate**.
 
 ## Quickstart
 

TOOLS_JS.md

@@ -14,7 +14,7 @@ Ctrl + Shift + j.
 By default the debug tools are disabled. You can enable debug tools as follows:
 
 ```typescript
-import {enableDebugTools} from 'angular2/platform/browser';
+import {enableDebugTools} from '@angular/platform-browser';
 
 bootstrap(Application).then((appRef) => {
   enableDebugTools(appRef);

browser-providers.conf.js

@@ -4,15 +4,16 @@
 var CIconfiguration = {
   'Chrome':       { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
   'Firefox':      { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  // FirefoxBeta should be required:true
-  // https://github.com/angular/angular/issues/7560
-  'FirefoxBeta':  { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: false}},
+  // FirefoxBeta and ChromeBeta should be target:'BS' or target:'SL', and required:true
+  // Currently deactivated due to https://github.com/angular/angular/issues/7560
+  'ChromeBeta':   { unitTest: {target: null, required: true}, e2e: {target: null, required: false}},
+  'FirefoxBeta':  { unitTest: {target: null, required: false}, e2e: {target: null, required: false}},
   'ChromeDev':    { unitTest: {target: null, required: true}, e2e: {target: null, required: true}},
   'FirefoxDev':   { unitTest: {target: null, required: true}, e2e: {target: null, required: true}},
   'IE9':          { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
   'IE10':         { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
   'IE11':         { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
-  'Edge':         { unitTest: {target: 'SL', required: true}, e2e: {target: null, required: true}},
+  'Edge':         { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
   'Android4.1':   { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
   'Android4.2':   { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
   'Android4.3':   { unitTest: {target: 'SL', required: false}, e2e: {target: null, required: true}},
@@ -23,8 +24,7 @@ var CIconfiguration = {
   'Safari9':      { unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
   'iOS7':         { unitTest: {target: 'BS', required: true}, e2e: {target: null, required: true}},
   'iOS8':         { unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
-  // TODO(mlaval): iOS9 deactivated as not reliable, reactivate after https://github.com/angular/angular/issues/5408
-  'iOS9':         { unitTest: {target: null, required: false}, e2e: {target: null, required: true}},
+  'iOS9':         { unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}},
   'WindowsPhone': { unitTest: {target: 'BS', required: false}, e2e: {target: null, required: true}}
 };
 
@@ -38,7 +38,7 @@ var customLaunchers = {
   'SL_CHROME': {
     base: 'SauceLabs',
     browserName: 'chrome',
-    version: '46'
+    version: '50'
   },
   'SL_CHROMEBETA': {
     base: 'SauceLabs',
@@ -53,7 +53,7 @@ var customLaunchers = {
   'SL_FIREFOX': {
     base: 'SauceLabs',
     browserName: 'firefox',
-    version: '42'
+    version: '45'
   },
   'SL_FIREFOXBETA': {
     base: 'SauceLabs',
@@ -121,9 +121,9 @@ var customLaunchers = {
   },
   'SL_EDGE': {
     base: 'SauceLabs',
-    browserName: 'microsoftedge',
+    browserName: 'MicrosoftEdge',
     platform: 'Windows 10',
-    version: '20.10240'
+    version: '13.10586'
   },
   'SL_ANDROID4.1': {
     base: 'SauceLabs',
@@ -299,12 +299,7 @@ module.exports = {
   customLaunchers: customLaunchers,
   sauceAliases: sauceAliases,
   browserstackAliases: browserstackAliases
-}
-
-if (process.env.TRAVIS) {
-  process.env.SAUCE_ACCESS_KEY = process.env.SAUCE_ACCESS_KEY.split('').reverse().join('');
-  process.env.BROWSER_STACK_ACCESS_KEY = process.env.BROWSER_STACK_ACCESS_KEY.split('').reverse().join('');
-}
+};
 
 function buildConfiguration(type, target, required) {
   return Object.keys(CIconfiguration)

build.sh

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+
+set -e -o pipefail
+
+cd `dirname $0`
+
+export NODE_PATH=${NODE_PATH}:$(pwd)/dist/all:$(pwd)/dist/tools
+
+
+rm -rf ./dist/all/
+mkdir -p ./dist/all/
+
+TSCONFIG=./tools/tsconfig.json
+echo "====== (all)COMPILING: \$(npm bin)/tsc -p ${TSCONFIG} ====="
+$(npm bin)/tsc -p ${TSCONFIG}
+cp ./tools/@angular/tsc-wrapped/package.json ./dist/tools/@angular/tsc-wrapped
+
+echo "====== Copying files needed for e2e tests ====="
+cp -r ./modules/playground ./dist/all/
+cp -r ./modules/playground/favicon.ico ./dist/
+#rsync -aP ./modules/playground/* ./dist/all/playground/
+mkdir ./dist/all/playground/vendor
+cd ./dist/all/playground/vendor
+ln -s ../../../../node_modules/es6-shim/es6-shim.js .
+ln -s ../../../../node_modules/zone.js/dist/zone.js .
+ln -s ../../../../node_modules/zone.js/dist/long-stack-trace-zone.js .
+ln -s ../../../../node_modules/systemjs/dist/system.src.js .
+ln -s ../../../../node_modules/base64-js/lib/b64.js .
+ln -s ../../../../node_modules/reflect-metadata/Reflect.js .
+ln -s ../../../../node_modules/rxjs .
+ln -s ../../../../node_modules/angular/angular.js .
+cd -
+
+
+TSCONFIG=./modules/tsconfig.json
+echo "====== (all)COMPILING: \$(npm bin)/tsc -p ${TSCONFIG} ====="
+# compile ts code
+TSC="node dist/tools/@angular/tsc-wrapped/src/main"
+$TSC -p modules/tsconfig.json
+
+rm -rf ./dist/packages-dist
+
+for PACKAGE in \
+  core \
+  compiler \
+  common \
+  forms \
+  platform-browser \
+  platform-browser-dynamic \
+  platform-server \
+  http \
+  router \
+  router-deprecated \
+  upgrade \
+  compiler-cli
+do
+  SRCDIR=./modules/@angular/${PACKAGE}
+  DESTDIR=./dist/packages-dist/${PACKAGE}
+  UMD_ES6_PATH=${DESTDIR}/esm/${PACKAGE}.umd.js
+  UMD_ES5_PATH=${DESTDIR}/bundles/${PACKAGE}.umd.js
+  UMD_ES5_MIN_PATH=${DESTDIR}/bundles/${PACKAGE}.umd.min.js
+
+  if [[ ${PACKAGE} == "router-deprecated" ]]; then
+    echo "======      COMPILING: \$(npm bin)/tsc -p ${SRCDIR}/tsconfig-es5.json        ====="
+    $(npm bin)/tsc -p ${SRCDIR}/tsconfig-es5.json
+  else
+    echo "======      COMPILING: ${TSC} -p ${SRCDIR}/tsconfig-es5.json        ====="
+    $TSC -p ${SRCDIR}/tsconfig-es5.json
+  fi
+
+  cp ${SRCDIR}/package.json ${DESTDIR}/
+
+
+  echo "======      TSC 1.8 d.ts compat for ${DESTDIR}   ====="
+  # safely strips 'readonly' specifier from d.ts files to make them compatible with tsc 1.8
+  if [[ ${TRAVIS} ]]; then
+    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i    -e 's/\(^ *(static |private )*\)*readonly  */\1/g'
+    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i    -E 's/^( +)abstract ([[:alnum:]]+\:)/\1\2/g'
+  else
+    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i '' -e 's/\(^ *(static |private )*\)*readonly  */\1/g'
+    find ${DESTDIR} -type f -name '*.d.ts' -print0 | xargs -0 sed -i '' -E 's/^( +)abstract ([[:alnum:]]+\:)/\1\2/g'
+  fi
+
+  if [[ ${PACKAGE} != compiler-cli ]]; then
+
+    if [[ ${PACKAGE} == "router-deprecated" ]]; then
+      echo "====== (esm)COMPILING: \$(npm bin)/tsc -p ${SRCDIR}/tsconfig-es2015.json ====="
+      $(npm bin)/tsc --emitDecoratorMetadata -p ${SRCDIR}/tsconfig-es2015.json
+    else
+      echo "====== (esm)COMPILING: $TSC -p ${SRCDIR}/tsconfig-es2015.json ====="
+      $TSC -p ${SRCDIR}/tsconfig-es2015.json
+    fi
+
+    echo "======      BUNDLING: ${SRCDIR} ====="
+    mkdir ${DESTDIR}/bundles
+
+    if [[ ${PACKAGE} != router ]]; then
+      (
+        cd  ${SRCDIR}
+        echo "..."  # here just to have grep match something and not exit with 1
+        ../../../node_modules/.bin/rollup -c rollup.config.js
+      ) 2>&1 | grep -v "as external dependency"
+
+      $(npm bin)/tsc  \
+          --out ${UMD_ES5_PATH} \
+          --target es5 \
+          --lib "es6,dom" \
+          --allowJs \
+          ${UMD_ES6_PATH}
+
+      rm ${UMD_ES6_PATH}
+
+      cat ./modules/@angular/license-banner.txt > ${UMD_ES5_PATH}.tmp
+      cat ${UMD_ES5_PATH} >> ${UMD_ES5_PATH}.tmp
+      mv ${UMD_ES5_PATH}.tmp ${UMD_ES5_PATH}
+
+      $(npm bin)/uglifyjs -c --screw-ie8 -o ${UMD_ES5_MIN_PATH} ${UMD_ES5_PATH}
+    fi
+  fi
+done

circle.yml

@@ -5,17 +5,7 @@ machine:
 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
+    - gulp lint

karma-js.conf.js

@@ -11,7 +11,7 @@ module.exports = function(config) {
     files: [
       // Sources and specs.
       // Loaded through the System loader, in `test-main.js`.
-      {pattern: 'dist/js/dev/es5/**', included: false, watched: false},
+      {pattern: 'dist/all/@angular/**/*.js', included: false, watched: true},
 
       'node_modules/es6-shim/es6-shim.js',
       // include Angular v1 for upgrade module testing
@@ -20,18 +20,28 @@ module.exports = function(config) {
       'node_modules/zone.js/dist/zone.js',
       'node_modules/zone.js/dist/long-stack-trace-zone.js',
       'node_modules/zone.js/dist/jasmine-patch.js',
+      'node_modules/zone.js/dist/async-test.js',
+      'node_modules/zone.js/dist/fake-async-test.js',
 
       // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'modules/angular2/src/testing/shims_for_IE.js',
+      'shims_for_IE.js',
       'node_modules/systemjs/dist/system.src.js',
       {pattern: 'node_modules/rxjs/**', included: false, watched: false, served: true},
       'node_modules/reflect-metadata/Reflect.js',
       'tools/build/file2modulename.js',
       'test-main.js',
-      {pattern: 'modules/**/test/**/static_assets/**', included: false, watched: false}
+      {pattern: 'dist/all/empty.*', included: false, watched: false},
+      {pattern: 'modules/@angular/platform-browser/test/static_assets/**', included: false, watched: false},
+      {pattern: 'modules/@angular/platform-browser/test/browser/static_assets/**', included: false, watched: false}
     ],
 
-    exclude: ['dist/js/dev/es5/**/e2e_test/**', 'dist/js/dev/es5/angular2/examples/**', 'dist/angular1_router.js'],
+    exclude: [
+      'dist/all/@angular/**/e2e_test/**',
+      'dist/all/@angular/examples/**',
+      'dist/all/@angular/compiler-cli/**',
+      'dist/all/angular1_router.js',
+      'dist/all/@angular/platform-browser/testing/e2e_util.js'
+    ],
 
     customLaunchers: browserProvidersConf.customLaunchers,
 
@@ -41,7 +51,6 @@ module.exports = function(config) {
       'karma-sauce-launcher',
       'karma-chrome-launcher',
       'karma-sourcemap-loader',
-      'karma-dart',
       internalAngularReporter
     ],
 
@@ -52,11 +61,12 @@ module.exports = function(config) {
     reporters: ['internal-angular'],
     sauceLabs: {
       testName: 'Angular2',
+      retryLimit: 3,
       startConnect: false,
       recordVideo: false,
       recordScreenshots: false,
       options: {
-        'selenium-version': '2.48.2',
+        'selenium-version': '2.53.0',
         'command-timeout': 600,
         'idle-timeout': 600,
         'max-duration': 5400
@@ -66,19 +76,23 @@ module.exports = function(config) {
     browserStack: {
       project: 'Angular2',
       startTunnel: false,
-      retryLimit: 1,
+      retryLimit: 3,
       timeout: 600,
       pollingTimeout: 10000
     },
 
     browsers: ['Chrome'],
 
-    port: 9876
+    port: 9876,
+    captureTimeout: 60000,
+    browserDisconnectTimeout : 60000,
+    browserDisconnectTolerance : 3,
+    browserNoActivityTimeout : 60000,
   });
 
   if (process.env.TRAVIS) {
     var buildId = 'TRAVIS #' + process.env.TRAVIS_BUILD_NUMBER + ' (' + process.env.TRAVIS_BUILD_ID + ')';
-    if (process.env.MODE.startsWith('saucelabs')) {
+    if (process.env.CI_MODE.startsWith('saucelabs')) {
       config.sauceLabs.build = buildId;
       config.sauceLabs.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
 
@@ -88,7 +102,7 @@ module.exports = function(config) {
       config.transports = ['polling'];
     }
 
-    if (process.env.MODE.startsWith('browserstack')) {
+    if (process.env.CI_MODE.startsWith('browserstack')) {
       config.browserStack.build = buildId;
       config.browserStack.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
     }

modules/@angular/common/common.dart

@@ -0,0 +1 @@
+export 'index.dart';

modules/@angular/common/index.ts

@@ -0,0 +1,5 @@
+export * from './src/pipes';
+export * from './src/directives';
+export * from './src/forms-deprecated';
+export * from './src/common_directives';
+export * from './src/location';

modules/@angular/common/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@angular/common",
+  "version": "0.0.0-PLACEHOLDER",
+  "description": "",
+  "main": "index.js",
+  "jsnext:main": "esm/index.js",
+  "typings": "index.d.ts",
+  "author": "angular",
+  "license": "MIT",
+  "peerDependencies": {
+    "@angular/core": "0.0.0-PLACEHOLDER"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular.git"
+  }
+}

modules/@angular/common/rollup.config.js

@@ -0,0 +1,17 @@
+
+export default {
+  entry: '../../../dist/packages-dist/common/esm/index.js',
+  dest: '../../../dist/packages-dist/common/esm/common.umd.js',
+  format: 'umd',
+  moduleName: 'ng.common',
+  globals: {
+    '@angular/core': 'ng.core',
+    'rxjs/Subject': 'Rx',
+    'rxjs/observable/PromiseObservable': 'Rx', // this is wrong, but this stuff has changed in rxjs b.6 so we need to fix it when we update.
+    'rxjs/operator/toPromise': 'Rx.Observable.prototype',
+    'rxjs/Observable': 'Rx'
+  },
+  plugins: [
+//    nodeResolve({ jsnext: true, main: true }),
+  ]
+}

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

@@ -1,7 +1,8 @@
-import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
+import {Type} from '@angular/core';
 
-import {FORM_DIRECTIVES} from './forms';
 import {CORE_DIRECTIVES} from './directives';
+import {FORM_DIRECTIVES} from './forms-deprecated';
+
 
 /**
  * A collection of Angular core directives that are likely to be used in each and every Angular
@@ -17,7 +18,7 @@ import {CORE_DIRECTIVES} from './directives';
  *
  * ```typescript
  * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, NgModel, NgForm} from
- * 'angular2/common';
+ * '@angular/common';
  * import {OtherDirective} from './myDirectives';
  *
  * @Component({
@@ -33,7 +34,7 @@ import {CORE_DIRECTIVES} from './directives';
  * one could import all the common directives at once:
  *
  * ```typescript
- * import {COMMON_DIRECTIVES} from 'angular2/common';
+ * import {COMMON_DIRECTIVES} from '@angular/common';
  * import {OtherDirective} from './myDirectives';
  *
  * @Component({
@@ -45,5 +46,7 @@ import {CORE_DIRECTIVES} from './directives';
  *   ...
  * }
  * ```
+ *
+ * @experimental Contains forms which are experimental.
  */
-export const COMMON_DIRECTIVES: Type[][] = CONST_EXPR([CORE_DIRECTIVES, FORM_DIRECTIVES]);
+export const COMMON_DIRECTIVES: Type[][] = /*@ts2dart_const*/[CORE_DIRECTIVES, FORM_DIRECTIVES];

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

@@ -3,11 +3,11 @@
  * @description
  * Common directives shipped with Angular.
  */
+export {CORE_DIRECTIVES} from './directives/core_directives';
 export {NgClass} from './directives/ng_class';
 export {NgFor} from './directives/ng_for';
 export {NgIf} from './directives/ng_if';
+export {NgLocalization, NgPlural, NgPluralCase} from './directives/ng_plural';
 export {NgStyle} from './directives/ng_style';
-export {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './directives/ng_switch';
-export {NgPlural, NgPluralCase, NgLocalization} from './directives/ng_plural';
-export * from './directives/observable_list_diff';
-export {CORE_DIRECTIVES} from './directives/core_directives';
+export {NgSwitch, NgSwitchCase, NgSwitchDefault} from './directives/ng_switch';
+export {NgTemplateOutlet} from './directives/ng_template_outlet';

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

@@ -1,10 +1,14 @@
-import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
+import {Type} from '../facade/lang';
+
 import {NgClass} from './ng_class';
 import {NgFor} from './ng_for';
 import {NgIf} from './ng_if';
-import {NgStyle} from './ng_style';
-import {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './ng_switch';
 import {NgPlural, NgPluralCase} from './ng_plural';
+import {NgStyle} from './ng_style';
+import {NgSwitch, NgSwitchCase, NgSwitchDefault} from './ng_switch';
+import {NgTemplateOutlet} from './ng_template_outlet';
+
+
 
 /**
  * A collection of Angular core directives that are likely to be used in each and every Angular
@@ -18,7 +22,7 @@ import {NgPlural, NgPluralCase} from './ng_plural';
  * Instead of writing:
  *
  * ```typescript
- * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/common';
+ * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from '@angular/common';
  * import {OtherDirective} from './myDirectives';
  *
  * @Component({
@@ -33,7 +37,7 @@ import {NgPlural, NgPluralCase} from './ng_plural';
  * one could import all the core directives at once:
  *
  * ```typescript
- * import {CORE_DIRECTIVES} from 'angular2/common';
+ * import {CORE_DIRECTIVES} from '@angular/common';
  * import {OtherDirective} from './myDirectives';
  *
  * @Component({
@@ -45,15 +49,18 @@ import {NgPlural, NgPluralCase} from './ng_plural';
  *   ...
  * }
  * ```
+ *
+ * @stable
  */
-export const CORE_DIRECTIVES: Type[] = CONST_EXPR([
+export const CORE_DIRECTIVES: Type[] = /*@ts2dart_const*/[
   NgClass,
   NgFor,
   NgIf,
+  NgTemplateOutlet,
   NgStyle,
   NgSwitch,
-  NgSwitchWhen,
+  NgSwitchCase,
   NgSwitchDefault,
   NgPlural,
-  NgPluralCase
-]);
+  NgPluralCase,
+];

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

@@ -1,18 +1,8 @@
-import {isPresent, isString, isArray} from 'angular2/src/facade/lang';
-import {
-  DoCheck,
-  OnDestroy,
-  Directive,
-  ElementRef,
-  IterableDiffers,
-  KeyValueDiffers,
-  Renderer,
-  IterableDiffer,
-  KeyValueDiffer,
-  CollectionChangeRecord,
-  KeyValueChangeRecord
-} from 'angular2/core';
-import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collection';
+import {CollectionChangeRecord, Directive, DoCheck, ElementRef, IterableDiffer, IterableDiffers, KeyValueChangeRecord, KeyValueDiffer, KeyValueDiffers, OnDestroy, Renderer} from '@angular/core';
+
+import {StringMapWrapper, isListLikeIterable} from '../facade/collection';
+import {isArray, isPresent, isString} from '../facade/lang';
+
 
 /**
  * The `NgClass` directive conditionally adds and removes CSS classes on an HTML element based on
@@ -33,8 +23,8 @@ import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collecti
  * ### Example ([live demo](http://plnkr.co/edit/a4YdtmWywhJ33uqfpPPn?p=preview)):
  *
  * ```
- * import {Component} from 'angular2/core';
- * import {NgClass} from 'angular2/common';
+ * import {Component} from '@angular/core';
+ * import {NgClass} from '@angular/common';
  *
  * @Component({
  *   selector: 'toggle-button',
@@ -58,7 +48,7 @@ import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collecti
  *       color: gray;
  *       border: medium solid gray;
  *     }
- *   `]
+ *   `],
  *   directives: [NgClass]
  * })
  * class ToggleButton {
@@ -72,6 +62,8 @@ import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collecti
  *   }
  * }
  * ```
+ *
+ * @stable
  */
 @Directive({selector: '[ngClass]', inputs: ['rawClass: ngClass', 'initialClasses: class']})
 export class NgClass implements DoCheck, OnDestroy {
@@ -80,7 +72,8 @@ export class NgClass implements DoCheck, OnDestroy {
   private _initialClasses: string[] = [];
   private _rawClass: string[]|Set<string>;
 
-  constructor(private _iterableDiffers: IterableDiffers, private _keyValueDiffers: KeyValueDiffers,
+  constructor(
+      private _iterableDiffers: IterableDiffers, private _keyValueDiffers: KeyValueDiffers,
       private _ngEl: ElementRef, private _renderer: Renderer) {}
 
   set initialClasses(v: string) {
@@ -154,16 +147,16 @@ export class NgClass implements DoCheck, OnDestroy {
     this._initialClasses.forEach(className => this._toggleClass(className, !isCleanup));
   }
 
-  private _applyClasses(rawClassVal: string[] | Set<string>| {[key: string]: any},
-                        isCleanup: boolean) {
+  private _applyClasses(
+      rawClassVal: string[]|Set<string>|{[key: string]: any}, isCleanup: boolean) {
     if (isPresent(rawClassVal)) {
       if (isArray(rawClassVal)) {
         (<string[]>rawClassVal).forEach(className => this._toggleClass(className, !isCleanup));
       } else if (rawClassVal instanceof Set) {
         (<Set<string>>rawClassVal).forEach(className => this._toggleClass(className, !isCleanup));
       } else {
-        StringMapWrapper.forEach(<{[k: string]: any}>rawClassVal,
-                                 (expVal: any, className: string) => {
+        StringMapWrapper.forEach(
+            <{[k: string]: any}>rawClassVal, (expVal: any, className: string) => {
               if (isPresent(expVal)) this._toggleClass(className, !isCleanup);
             });
       }

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

@@ -1,37 +1,38 @@
-import {
-  DoCheck,
-  Directive,
-  ChangeDetectorRef,
-  IterableDiffer,
-  IterableDiffers,
-  ViewContainerRef,
-  TemplateRef,
-  EmbeddedViewRef,
-  TrackByFn
-} from 'angular2/core';
-import {isPresent, isBlank, stringify, getTypeNameForDebugging} from 'angular2/src/facade/lang';
-import {
-  DefaultIterableDiffer,
-  CollectionChangeRecord
-} from "../../core/change_detection/differs/default_iterable_differ";
-import {BaseException} from "../../facade/exceptions";
+import {ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, Directive, DoCheck, EmbeddedViewRef, IterableDiffer, IterableDiffers, TemplateRef, TrackByFn, ViewContainerRef} from '@angular/core';
+
+import {BaseException} from '../facade/exceptions';
+import {getTypeNameForDebugging, isBlank, isPresent} from '../facade/lang';
+
+export class NgForRow {
+  constructor(public $implicit: any, public index: number, public count: number) {}
+
+  get first(): boolean { return this.index === 0; }
+
+  get last(): boolean { return this.index === this.count - 1; }
+
+  get even(): boolean { return this.index % 2 === 0; }
+
+  get odd(): boolean { return !this.even; }
+}
 
 /**
  * The `NgFor` directive instantiates a template once per item from an iterable. The context for
  * each instantiated template inherits from the outer context with the given loop variable set
  * to the current item from the iterable.
  *
- * # Local Variables
+ * ### Local Variables
  *
  * `NgFor` provides several exported values that can be aliased to local variables:
  *
  * * `index` will be set to the current loop iteration for each template context.
+ * * `first` will be set to a boolean value indicating whether the item is the first one in the
+ *   iteration.
  * * `last` will be set to a boolean value indicating whether the item is the last one in the
  *   iteration.
  * * `even` will be set to a boolean value indicating whether this item has an even index.
  * * `odd` will be set to a boolean value indicating whether this item has an odd index.
  *
- * # Change Propagation
+ * ### Change Propagation
  *
  * When the contents of the iterator changes, `NgFor` makes the corresponding changes to the DOM:
  *
@@ -54,25 +55,29 @@ import {BaseException} from "../../facade/exceptions";
  * elements were deleted and all new elements inserted). This is an expensive operation and should
  * be avoided if possible.
  *
- * # Syntax
+ * ### Syntax
  *
- * - `<li *ngFor="#item of items; #i = index">...</li>`
- * - `<li template="ngFor #item of items; #i = index">...</li>`
- * - `<template ngFor #item [ngForOf]="items" #i="index"><li>...</li></template>`
+ * - `<li *ngFor="let item of items; let i = index">...</li>`
+ * - `<li template="ngFor let item of items; let i = index">...</li>`
+ * - `<template ngFor let-item [ngForOf]="items" let-i="index"><li>...</li></template>`
  *
  * ### Example
  *
  * See a [live demo](http://plnkr.co/edit/KVuXxDp0qinGDyo307QW?p=preview) for a more detailed
  * example.
+ *
+ * @stable
  */
 @Directive({selector: '[ngFor][ngForOf]', inputs: ['ngForTrackBy', 'ngForOf', 'ngForTemplate']})
 export class NgFor implements DoCheck {
   /** @internal */
   _ngForOf: any;
+  /** @internal */
   _ngForTrackBy: TrackByFn;
   private _differ: IterableDiffer;
 
-  constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef,
+  constructor(
+      private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef<NgForRow>,
       private _iterableDiffers: IterableDiffers, private _cdr: ChangeDetectorRef) {}
 
   set ngForOf(value: any) {
@@ -87,7 +92,7 @@ export class NgFor implements DoCheck {
     }
   }
 
-  set ngForTemplate(value: TemplateRef) {
+  set ngForTemplate(value: TemplateRef<NgForRow>) {
     if (isPresent(value)) {
       this._templateRef = value;
     }
@@ -106,15 +111,18 @@ export class NgFor implements DoCheck {
     // TODO(rado): check if change detection can produce a change record that is
     // easier to consume than current.
     var recordViewTuples: RecordViewTuple[] = [];
-    changes.forEachRemovedItem((removedRecord: CollectionChangeRecord) =>
+    changes.forEachRemovedItem(
+        (removedRecord: CollectionChangeRecord) =>
             recordViewTuples.push(new RecordViewTuple(removedRecord, null)));
 
-    changes.forEachMovedItem((movedRecord: CollectionChangeRecord) =>
+    changes.forEachMovedItem(
+        (movedRecord: CollectionChangeRecord) =>
             recordViewTuples.push(new RecordViewTuple(movedRecord, null)));
 
     var insertTuples = this._bulkRemove(recordViewTuples);
 
-    changes.forEachAddedItem((addedRecord: CollectionChangeRecord) =>
+    changes.forEachAddedItem(
+        (addedRecord: CollectionChangeRecord) =>
             insertTuples.push(new RecordViewTuple(addedRecord, null)));
 
     this._bulkInsert(insertTuples);
@@ -124,32 +132,32 @@ export class NgFor implements DoCheck {
     }
 
     for (var i = 0, ilen = this._viewContainer.length; i < ilen; i++) {
-      var viewRef = <EmbeddedViewRef>this._viewContainer.get(i);
-      viewRef.setLocal('last', i === ilen - 1);
+      var viewRef = <EmbeddedViewRef<NgForRow>>this._viewContainer.get(i);
+      viewRef.context.index = i;
+      viewRef.context.count = ilen;
     }
 
-    changes.forEachIdentityChange((record) => {
-      var viewRef = <EmbeddedViewRef>this._viewContainer.get(record.currentIndex);
-      viewRef.setLocal('\$implicit', record.item);
+    changes.forEachIdentityChange((record: any /** TODO #9100 */) => {
+      var viewRef = <EmbeddedViewRef<NgForRow>>this._viewContainer.get(record.currentIndex);
+      viewRef.context.$implicit = record.item;
     });
   }
 
-  private _perViewChange(view: EmbeddedViewRef, record: CollectionChangeRecord) {
-    view.setLocal('\$implicit', record.item);
-    view.setLocal('index', record.currentIndex);
-    view.setLocal('even', (record.currentIndex % 2 == 0));
-    view.setLocal('odd', (record.currentIndex % 2 == 1));
+  private _perViewChange(view: EmbeddedViewRef<NgForRow>, record: CollectionChangeRecord) {
+    view.context.$implicit = record.item;
   }
 
   private _bulkRemove(tuples: RecordViewTuple[]): RecordViewTuple[] {
-    tuples.sort((a: RecordViewTuple, b: RecordViewTuple) =>
+    tuples.sort(
+        (a: RecordViewTuple, b: RecordViewTuple) =>
             a.record.previousIndex - b.record.previousIndex);
     var movedTuples: RecordViewTuple[] = [];
     for (var i = tuples.length - 1; i >= 0; i--) {
       var tuple = tuples[i];
       // separate moved views from removed views.
       if (isPresent(tuple.record.currentIndex)) {
-        tuple.view = this._viewContainer.detach(tuple.record.previousIndex);
+        tuple.view =
+            <EmbeddedViewRef<NgForRow>>this._viewContainer.detach(tuple.record.previousIndex);
         movedTuples.push(tuple);
       } else {
         this._viewContainer.remove(tuple.record.previousIndex);
@@ -165,8 +173,8 @@ export class NgFor implements DoCheck {
       if (isPresent(tuple.view)) {
         this._viewContainer.insert(tuple.view, tuple.record.currentIndex);
       } else {
-        tuple.view =
-            this._viewContainer.createEmbeddedView(this._templateRef, tuple.record.currentIndex);
+        tuple.view = this._viewContainer.createEmbeddedView(
+            this._templateRef, new NgForRow(null, null, null), tuple.record.currentIndex);
       }
     }
     return tuples;
@@ -174,9 +182,9 @@ export class NgFor implements DoCheck {
 }
 
 class RecordViewTuple {
-  view: EmbeddedViewRef;
+  view: EmbeddedViewRef<NgForRow>;
   record: any;
-  constructor(record: any, view: EmbeddedViewRef) {
+  constructor(record: any, view: EmbeddedViewRef<NgForRow>) {
     this.record = record;
     this.view = view;
   }

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

@@ -1,5 +1,7 @@
-import {Directive, ViewContainerRef, TemplateRef} from 'angular2/core';
-import {isBlank} from 'angular2/src/facade/lang';
+import {Directive, TemplateRef, ViewContainerRef} from '@angular/core';
+
+import {isBlank} from '../facade/lang';
+
 
 /**
  * Removes or recreates a portion of the DOM tree based on an {expression}.
@@ -22,12 +24,15 @@ import {isBlank} from 'angular2/src/facade/lang';
  * - `<div *ngIf="condition">...</div>`
  * - `<div template="ngIf condition">...</div>`
  * - `<template [ngIf]="condition"><div>...</div></template>`
+ *
+ * @stable
  */
 @Directive({selector: '[ngIf]', inputs: ['ngIf']})
 export class NgIf {
   private _prevCondition: boolean = null;
 
-  constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef) {}
+  constructor(private _viewContainer: ViewContainerRef, private _templateRef: TemplateRef<Object>) {
+  }
 
   set ngIf(newCondition: any /* boolean */) {
     if (newCondition && (isBlank(this._prevCondition) || !this._prevCondition)) {

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

@@ -1,19 +1,15 @@
-import {
-  Directive,
-  ViewContainerRef,
-  TemplateRef,
-  ContentChildren,
-  QueryList,
-  Attribute,
-  AfterContentInit,
-  Input
-} from 'angular2/core';
-import {isPresent, NumberWrapper} from 'angular2/src/facade/lang';
-import {Map} from 'angular2/src/facade/collection';
+import {AfterContentInit, Attribute, ContentChildren, Directive, Input, QueryList, TemplateRef, ViewContainerRef} from '@angular/core';
+
+import {Map} from '../facade/collection';
+import {NumberWrapper, isPresent} from '../facade/lang';
+
 import {SwitchView} from './ng_switch';
 
 const _CATEGORY_DEFAULT = 'other';
 
+/**
+ * @experimental
+ */
 export abstract class NgLocalization { abstract getPluralCategory(value: any): string; }
 
 /**
@@ -45,7 +41,7 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
  *
  * @Component({
  *    selector: 'app',
- *    providers: [provide(NgLocalization, {useClass: MyLocalization})]
+ *    providers: [{provide: NgLocalization, useClass: MyLocalization}]
  * })
  * @View({
  *   template: `
@@ -70,18 +66,24 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
  * }
  *
  * ```
+ * @experimental
  */
 
 @Directive({selector: '[ngPluralCase]'})
 export class NgPluralCase {
+  /** @internal */
   _view: SwitchView;
-  constructor(@Attribute('ngPluralCase') public value: string, template: TemplateRef,
+  constructor(
+      @Attribute('ngPluralCase') public value: string, template: TemplateRef<Object>,
       viewContainer: ViewContainerRef) {
     this._view = new SwitchView(viewContainer, template);
   }
 }
 
 
+/**
+ * @experimental
+ */
 @Directive({selector: '[ngPlural]'})
 export class NgPlural implements AfterContentInit {
   private _switchValue: number;
@@ -134,7 +136,7 @@ export class NgPlural implements AfterContentInit {
   }
 
   /** @internal */
-  _isValueView(pluralCase: NgPluralCase): boolean { return pluralCase.value[0] === "="; }
+  _isValueView(pluralCase: NgPluralCase): boolean { return pluralCase.value[0] === '='; }
 
   /** @internal */
   _formatValue(pluralCase: NgPluralCase): any {

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

@@ -1,13 +1,7 @@
-import {
-  DoCheck,
-  KeyValueDiffer,
-  KeyValueDiffers,
-  ElementRef,
-  Directive,
-  Renderer
-} from 'angular2/core';
-import {isPresent, isBlank, print} from 'angular2/src/facade/lang';
-import {KeyValueChangeRecord} from "../../core/change_detection/differs/default_keyvalue_differ";
+import {Directive, DoCheck, ElementRef, KeyValueChangeRecord, KeyValueDiffer, KeyValueDiffers, Renderer} from '@angular/core';
+
+import {isBlank, isPresent} from '../facade/lang';
+
 
 /**
  * The `NgStyle` directive changes styles based on a result of expression evaluation.
@@ -24,8 +18,8 @@ import {KeyValueChangeRecord} from "../../core/change_detection/differs/default_
  * ### Example ([live demo](http://plnkr.co/edit/YamGS6GkUh9GqWNQhCyM?p=preview)):
  *
  * ```
- * import {Component} from 'angular2/core';
- * import {NgStyle} from 'angular2/common';
+ * import {Component} from '@angular/core';
+ * import {NgStyle} from '@angular/common';
  *
  * @Component({
  *  selector: 'ngStyle-example',
@@ -59,6 +53,8 @@ import {KeyValueChangeRecord} from "../../core/change_detection/differs/default_
  *
  * In this example the `font-style`, `font-size` and `font-weight` styles will be updated
  * based on the `style` property's value changes.
+ *
+ * @stable
  */
 @Directive({selector: '[ngStyle]', inputs: ['rawStyle: ngStyle']})
 export class NgStyle implements DoCheck {
@@ -67,8 +63,8 @@ export class NgStyle implements DoCheck {
   /** @internal */
   _differ: KeyValueDiffer;
 
-  constructor(private _differs: KeyValueDiffers, private _ngEl: ElementRef,
-              private _renderer: Renderer) {}
+  constructor(
+      private _differs: KeyValueDiffers, private _ngEl: ElementRef, private _renderer: Renderer) {}
 
   set rawStyle(v: {[key: string]: string}) {
     this._rawStyle = v;

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

@@ -1,11 +1,13 @@
-import {Directive, Host, ViewContainerRef, TemplateRef} from 'angular2/core';
-import {isPresent, isBlank, normalizeBlank, CONST_EXPR} from 'angular2/src/facade/lang';
-import {ListWrapper, Map} from 'angular2/src/facade/collection';
+import {Directive, Host, TemplateRef, ViewContainerRef} from '@angular/core';
 
-const _WHEN_DEFAULT = CONST_EXPR(new Object());
+import {ListWrapper, Map} from '../facade/collection';
+import {isBlank, isPresent, normalizeBlank} from '../facade/lang';
+
+const _CASE_DEFAULT = /*@ts2dart_const*/ new Object();
 
 export class SwitchView {
-  constructor(private _viewContainerRef: ViewContainerRef, private _templateRef: TemplateRef) {}
+  constructor(
+      private _viewContainerRef: ViewContainerRef, private _templateRef: TemplateRef<Object>) {}
 
   create(): void { this._viewContainerRef.createEmbeddedView(this._templateRef); }
 
@@ -15,17 +17,17 @@ export class SwitchView {
 /**
  * Adds or removes DOM sub-trees when their match expressions match the switch expression.
  *
- * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
+ * Elements within `NgSwitch` but without `ngSwitchCase` or `NgSwitchDefault` directives will be
  * preserved at the location as specified in the template.
  *
  * `NgSwitch` simply inserts nested elements based on which match expression matches the value
  * obtained from the evaluated switch expression. In other words, you define a container element
  * (where you place the directive with a switch expression on the
- * **`[ngSwitch]="..."` attribute**), define any inner elements inside of the directive and
- * place a `[ngSwitchWhen]` attribute per element.
+ * `[ngSwitch]="..."` attribute), define any inner elements inside of the directive and
+ * place a `[ngSwitchCase]` attribute per element.
  *
- * The `ngSwitchWhen` property is used to inform `NgSwitch` which element to display when the
- * expression is evaluated. If a matching expression is not found via a `ngSwitchWhen` property
+ * The `ngSwitchCase` property is used to inform `NgSwitch` which element to display when the
+ * expression is evaluated. If a matching expression is not found via a `ngSwitchCase` property
  * then an element with the `ngSwitchDefault` attribute is displayed.
  *
  * ### Example ([live demo](http://plnkr.co/edit/DQMTII95CbuqWrl3lYAs?p=preview))
@@ -38,24 +40,24 @@ export class SwitchView {
  *     <button (click)="inc()">Increment</button>
  *
  *     <div [ngSwitch]="value">
- *       <p *ngSwitchWhen="'init'">increment to start</p>
- *       <p *ngSwitchWhen="0">0, increment again</p>
- *       <p *ngSwitchWhen="1">1, increment again</p>
- *       <p *ngSwitchWhen="2">2, stop incrementing</p>
+ *       <p *ngSwitchCase="'init'">increment to start</p>
+ *       <p *ngSwitchCase="0">0, increment again</p>
+ *       <p *ngSwitchCase="1">1, increment again</p>
+ *       <p *ngSwitchCase="2">2, stop incrementing</p>
  *       <p *ngSwitchDefault>&gt; 2, STOP!</p>
  *     </div>
  *
  *     <!-- alternate syntax -->
  *
  *     <p [ngSwitch]="value">
- *       <template ngSwitchWhen="init">increment to start</template>
- *       <template [ngSwitchWhen]="0">0, increment again</template>
- *       <template [ngSwitchWhen]="1">1, increment again</template>
- *       <template [ngSwitchWhen]="2">2, stop incrementing</template>
+ *       <template ngSwitchCase="init">increment to start</template>
+ *       <template [ngSwitchCase]="0">0, increment again</template>
+ *       <template [ngSwitchCase]="1">1, increment again</template>
+ *       <template [ngSwitchCase]="2">2, stop incrementing</template>
  *       <template ngSwitchDefault>&gt; 2, STOP!</template>
  *     </p>
  *   `,
- *   directives: [NgSwitch, NgSwitchWhen, NgSwitchDefault]
+ *   directives: [NgSwitch, ngSwitchCase, NgSwitchDefault]
  * })
  * export class App {
  *   value = 'init';
@@ -67,6 +69,8 @@ export class SwitchView {
  *
  * bootstrap(App).catch(err => console.error(err));
  * ```
+ *
+ * @experimental
  */
 @Directive({selector: '[ngSwitch]', inputs: ['ngSwitch']})
 export class NgSwitch {
@@ -84,7 +88,7 @@ export class NgSwitch {
     var views = this._valueViews.get(value);
     if (isBlank(views)) {
       this._useDefault = true;
-      views = normalizeBlank(this._valueViews.get(_WHEN_DEFAULT));
+      views = normalizeBlank(this._valueViews.get(_CASE_DEFAULT));
     }
     this._activateViews(views);
 
@@ -92,14 +96,14 @@ export class NgSwitch {
   }
 
   /** @internal */
-  _onWhenValueChanged(oldWhen: any, newWhen: any, view: SwitchView): void {
-    this._deregisterView(oldWhen, view);
-    this._registerView(newWhen, view);
+  _onCaseValueChanged(oldCase: any, newCase: any, view: SwitchView): void {
+    this._deregisterView(oldCase, view);
+    this._registerView(newCase, view);
 
-    if (oldWhen === this._switchValue) {
+    if (oldCase === this._switchValue) {
       view.destroy();
       ListWrapper.remove(this._activeViews, view);
-    } else if (newWhen === this._switchValue) {
+    } else if (newCase === this._switchValue) {
       if (this._useDefault) {
         this._useDefault = false;
         this._emptyAllActiveViews();
@@ -111,7 +115,7 @@ export class NgSwitch {
     // Switch to default when there is no more active ViewContainers
     if (this._activeViews.length === 0 && !this._useDefault) {
       this._useDefault = true;
-      this._activateViews(this._valueViews.get(_WHEN_DEFAULT));
+      this._activateViews(this._valueViews.get(_CASE_DEFAULT));
     }
   }
 
@@ -147,8 +151,8 @@ export class NgSwitch {
 
   /** @internal */
   _deregisterView(value: any, view: SwitchView): void {
-    // `_WHEN_DEFAULT` is used a marker for non-registered whens
-    if (value === _WHEN_DEFAULT) return;
+    // `_CASE_DEFAULT` is used a marker for non-registered cases
+    if (value === _CASE_DEFAULT) return;
     var views = this._valueViews.get(value);
     if (views.length == 1) {
       this._valueViews.delete(value);
@@ -159,30 +163,45 @@ export class NgSwitch {
 }
 
 /**
- * Insert the sub-tree when the `ngSwitchWhen` expression evaluates to the same value as the
+ * Insert the sub-tree when the `ngSwitchCase` expression evaluates to the same value as the
  * enclosing switch expression.
  *
  * If multiple match expression match the switch expression value, all of them are displayed.
  *
  * See {@link NgSwitch} for more details and example.
+ *
+ * @experimental
  */
-@Directive({selector: '[ngSwitchWhen]', inputs: ['ngSwitchWhen']})
-export class NgSwitchWhen {
-  // `_WHEN_DEFAULT` is used as a marker for a not yet initialized value
+@Directive({selector: '[ngSwitchCase],[ngSwitchWhen]', inputs: ['ngSwitchCase', 'ngSwitchWhen']})
+export class NgSwitchCase {
+  // `_CASE_DEFAULT` is used as a marker for a not yet initialized value
   /** @internal */
-  _value: any = _WHEN_DEFAULT;
+  _value: any = _CASE_DEFAULT;
   /** @internal */
   _view: SwitchView;
+  // TODO: remove when fully deprecated
+  /** @internal */
+  _warned: boolean;
   private _switch: NgSwitch;
 
-  constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef,
+  constructor(
+      viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>,
       @Host() ngSwitch: NgSwitch) {
     this._switch = ngSwitch;
     this._view = new SwitchView(viewContainer, templateRef);
   }
 
+  set ngSwitchCase(value: any) {
+    this._switch._onCaseValueChanged(this._value, value, this._view);
+    this._value = value;
+  }
+
   set ngSwitchWhen(value: any) {
-    this._switch._onWhenValueChanged(this._value, value, this._view);
+    if (!this._warned) {
+      this._warned = true;
+      console.warn('*ngSwitchWhen is deprecated and will be removed. Use *ngSwitchCase instead');
+    }
+    this._switch._onCaseValueChanged(this._value, value, this._view);
     this._value = value;
   }
 }
@@ -192,11 +211,14 @@ export class NgSwitchWhen {
  * value.
  *
  * See {@link NgSwitch} for more details and example.
+ *
+ * @experimental
  */
 @Directive({selector: '[ngSwitchDefault]'})
 export class NgSwitchDefault {
-  constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef,
+  constructor(
+      viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>,
       @Host() sswitch: NgSwitch) {
-    sswitch._registerView(_WHEN_DEFAULT, new SwitchView(viewContainer, templateRef));
+    sswitch._registerView(_CASE_DEFAULT, new SwitchView(viewContainer, templateRef));
   }
 }

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

@@ -0,0 +1,56 @@
+import {Directive, EmbeddedViewRef, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+
+import {isPresent} from '../facade/lang';
+
+
+
+/**
+ * Creates and inserts an embedded view based on a prepared `TemplateRef`.
+ * You can attach a context object to the `EmbeddedViewRef` by setting `[ngOutletContext]`.
+ * `[ngOutletContext]` should be an object, the object's keys will be the local template variables
+ * available within the `TemplateRef`.
+ *
+ * Note: using the key `$implicit` in the context object will set it's value as default.
+ *
+ * ### Syntax
+ * - `<template [ngTemplateOutlet]="templateRefExpression"
+ * [ngOutletContext]="objectExpression"></template>`
+ *
+ * @experimental
+ */
+@Directive({selector: '[ngTemplateOutlet]'})
+export class NgTemplateOutlet {
+  private _viewRef: EmbeddedViewRef<any>;
+  private _context: Object;
+  private _templateRef: TemplateRef<any>;
+
+  constructor(private _viewContainerRef: ViewContainerRef) {}
+
+  @Input()
+  set ngOutletContext(context: Object) {
+    if (this._context !== context) {
+      this._context = context;
+      if (isPresent(this._viewRef)) {
+        this.createView();
+      }
+    }
+  }
+
+  @Input()
+  set ngTemplateOutlet(templateRef: TemplateRef<Object>) {
+    if (this._templateRef !== templateRef) {
+      this._templateRef = templateRef;
+      this.createView();
+    }
+  }
+
+  private createView() {
+    if (isPresent(this._viewRef)) {
+      this._viewContainerRef.remove(this._viewContainerRef.indexOf(this._viewRef));
+    }
+
+    if (isPresent(this._templateRef)) {
+      this._viewRef = this._viewContainerRef.createEmbeddedView(this._templateRef, this._context);
+    }
+  }
+}

modules/@angular/common/src/facade

@@ -0,0 +1 @@
+../../facade/src

modules/@angular/common/src/forms-deprecated.ts

@@ -0,0 +1,51 @@
+/**
+ * @module
+ * @description
+ * This module is used for handling user input, by defining and building a {@link ControlGroup} that
+ * consists of
+ * {@link Control} objects, and mapping them onto the DOM. {@link Control} objects can then be used
+ * to read information
+ * from the form DOM elements.
+ *
+ * Forms providers are not included in default providers; you must import these providers
+ * explicitly.
+ */
+import {Type} from '@angular/core';
+
+import {RadioControlRegistry} from './forms-deprecated/directives/radio_control_value_accessor';
+import {FormBuilder} from './forms-deprecated/form_builder';
+
+export {FORM_DIRECTIVES, RadioButtonState} from './forms-deprecated/directives';
+export {AbstractControlDirective} from './forms-deprecated/directives/abstract_control_directive';
+export {CheckboxControlValueAccessor} from './forms-deprecated/directives/checkbox_value_accessor';
+export {ControlContainer} from './forms-deprecated/directives/control_container';
+export {ControlValueAccessor, NG_VALUE_ACCESSOR} from './forms-deprecated/directives/control_value_accessor';
+export {DefaultValueAccessor} from './forms-deprecated/directives/default_value_accessor';
+export {Form} from './forms-deprecated/directives/form_interface';
+export {NgControl} from './forms-deprecated/directives/ng_control';
+export {NgControlGroup} from './forms-deprecated/directives/ng_control_group';
+export {NgControlName} from './forms-deprecated/directives/ng_control_name';
+export {NgControlStatus} from './forms-deprecated/directives/ng_control_status';
+export {NgForm} from './forms-deprecated/directives/ng_form';
+export {NgFormControl} from './forms-deprecated/directives/ng_form_control';
+export {NgFormModel} from './forms-deprecated/directives/ng_form_model';
+export {NgModel} from './forms-deprecated/directives/ng_model';
+export {NgSelectOption, SelectControlValueAccessor} from './forms-deprecated/directives/select_control_value_accessor';
+export {MaxLengthValidator, MinLengthValidator, PatternValidator, RequiredValidator, Validator} from './forms-deprecated/directives/validators';
+export {FormBuilder} from './forms-deprecated/form_builder';
+export {AbstractControl, Control, ControlArray, ControlGroup} from './forms-deprecated/model';
+export {NG_ASYNC_VALIDATORS, NG_VALIDATORS, Validators} from './forms-deprecated/validators';
+
+
+/**
+ * Shorthand set of providers used for building Angular forms.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * bootstrap(MyApp, [FORM_PROVIDERS]);
+ * ```
+ *
+ * @experimental
+ */
+export const FORM_PROVIDERS: Type[] = /*@ts2dart_const*/[FormBuilder, RadioControlRegistry];

modules/@angular/common/src/forms-deprecated/directives.ts

@@ -1,52 +1,37 @@
-import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
-import {NgControlName} from './directives/ng_control_name';
-import {NgFormControl} from './directives/ng_form_control';
-import {NgModel} from './directives/ng_model';
-import {NgControlGroup} from './directives/ng_control_group';
-import {NgFormModel} from './directives/ng_form_model';
-import {NgForm} from './directives/ng_form';
-import {DefaultValueAccessor} from './directives/default_value_accessor';
+import {Type} from '@angular/core';
+
 import {CheckboxControlValueAccessor} from './directives/checkbox_value_accessor';
+import {DefaultValueAccessor} from './directives/default_value_accessor';
+import {NgControlGroup} from './directives/ng_control_group';
+import {NgControlName} from './directives/ng_control_name';
+import {NgControlStatus} from './directives/ng_control_status';
+import {NgForm} from './directives/ng_form';
+import {NgFormControl} from './directives/ng_form_control';
+import {NgFormModel} from './directives/ng_form_model';
+import {NgModel} from './directives/ng_model';
 import {NumberValueAccessor} from './directives/number_value_accessor';
 import {RadioControlValueAccessor} from './directives/radio_control_value_accessor';
-import {NgControlStatus} from './directives/ng_control_status';
-import {
-  SelectControlValueAccessor,
-  NgSelectOption
-} from './directives/select_control_value_accessor';
-import {
-  RequiredValidator,
-  MinLengthValidator,
-  MaxLengthValidator,
-  PatternValidator
-} from './directives/validators';
+import {NgSelectOption, SelectControlValueAccessor} from './directives/select_control_value_accessor';
+import {NgSelectMultipleOption, SelectMultipleControlValueAccessor} from './directives/select_multiple_control_value_accessor';
+import {MaxLengthValidator, MinLengthValidator, PatternValidator, RequiredValidator} from './directives/validators';
 
-export {NgControlName} from './directives/ng_control_name';
-export {NgFormControl} from './directives/ng_form_control';
-export {NgModel} from './directives/ng_model';
-export {NgControlGroup} from './directives/ng_control_group';
-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 {
-  SelectControlValueAccessor,
-  NgSelectOption
-} from './directives/select_control_value_accessor';
-export {
-  RequiredValidator,
-  MinLengthValidator,
-  MaxLengthValidator,
-  PatternValidator
-} from './directives/validators';
-export {NgControl} from './directives/ng_control';
 export {ControlValueAccessor} from './directives/control_value_accessor';
+export {DefaultValueAccessor} from './directives/default_value_accessor';
+export {NgControl} from './directives/ng_control';
+export {NgControlGroup} from './directives/ng_control_group';
+export {NgControlName} from './directives/ng_control_name';
+export {NgControlStatus} from './directives/ng_control_status';
+export {NgForm} from './directives/ng_form';
+export {NgFormControl} from './directives/ng_form_control';
+export {NgFormModel} from './directives/ng_form_model';
+export {NgModel} from './directives/ng_model';
+export {NumberValueAccessor} from './directives/number_value_accessor';
+export {RadioButtonState, RadioControlValueAccessor} from './directives/radio_control_value_accessor';
+export {NgSelectOption, SelectControlValueAccessor} from './directives/select_control_value_accessor';
+export {NgSelectMultipleOption, SelectMultipleControlValueAccessor} from './directives/select_multiple_control_value_accessor';
+export {MaxLengthValidator, MinLengthValidator, PatternValidator, RequiredValidator} from './directives/validators';
+
 
 /**
  *
@@ -63,8 +48,9 @@ export {ControlValueAccessor} from './directives/control_value_accessor';
  * })
  * class MyApp {}
  * ```
+ * @experimental
  */
-export const FORM_DIRECTIVES: Type[] = CONST_EXPR([
+export const FORM_DIRECTIVES: Type[] = /*@ts2dart_const*/[
   NgControlName,
   NgControlGroup,
 
@@ -74,15 +60,17 @@ export const FORM_DIRECTIVES: Type[] = CONST_EXPR([
   NgForm,
 
   NgSelectOption,
+  NgSelectMultipleOption,
   DefaultValueAccessor,
   NumberValueAccessor,
   CheckboxControlValueAccessor,
   SelectControlValueAccessor,
+  SelectMultipleControlValueAccessor,
   RadioControlValueAccessor,
   NgControlStatus,
 
   RequiredValidator,
   MinLengthValidator,
   MaxLengthValidator,
-  PatternValidator
-]);
+  PatternValidator,
+];

modules/@angular/common/src/forms-deprecated/directives/abstract_control_directive.ts

@@ -0,0 +1,33 @@
+import {unimplemented} from '../../facade/exceptions';
+import {isPresent} from '../../facade/lang';
+import {AbstractControl} from '../model';
+
+
+/**
+ * Base class for control directives.
+ *
+ * Only used internally in the forms module.
+ *
+ * @experimental
+ */
+export abstract class AbstractControlDirective {
+  get control(): AbstractControl { return unimplemented(); }
+
+  get value(): any { return isPresent(this.control) ? this.control.value : null; }
+
+  get valid(): boolean { return isPresent(this.control) ? this.control.valid : null; }
+
+  get errors(): {[key: string]: any} {
+    return isPresent(this.control) ? this.control.errors : null;
+  }
+
+  get pristine(): boolean { return isPresent(this.control) ? this.control.pristine : null; }
+
+  get dirty(): boolean { return isPresent(this.control) ? this.control.dirty : null; }
+
+  get touched(): boolean { return isPresent(this.control) ? this.control.touched : null; }
+
+  get untouched(): boolean { return isPresent(this.control) ? this.control.untouched : null; }
+
+  get path(): string[] { return null; }
+}

modules/@angular/common/src/forms-deprecated/directives/checkbox_value_accessor.ts

@@ -1,10 +1,12 @@
-import {Directive, Renderer, ElementRef, Self, forwardRef, Provider} from 'angular2/core';
+import {Directive, ElementRef, Renderer, forwardRef} from '@angular/core';
 
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
 
-const CHECKBOX_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => CheckboxControlValueAccessor), multi: true}));
+export const CHECKBOX_VALUE_ACCESSOR: any = /*@ts2dart_const*/ {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => CheckboxControlValueAccessor),
+  multi: true
+};
 
 /**
  * The accessor for writing a value and listening to changes on a checkbox input element.
@@ -13,6 +15,8 @@ const CHECKBOX_VALUE_ACCESSOR = CONST_EXPR(new Provider(
  *  ```
  *  <input type="checkbox" ngControl="rememberLogin">
  *  ```
+ *
+ *  @experimental
  */
 @Directive({
   selector:

modules/@angular/common/src/forms-deprecated/directives/control_container.ts

@@ -1,10 +1,13 @@
-import {Form} from './form_interface';
 import {AbstractControlDirective} from './abstract_control_directive';
+import {Form} from './form_interface';
+
 
 /**
  * A directive that contains multiple {@link NgControl}s.
  *
  * Only used by the forms module.
+ *
+ * @experimental
  */
 export class ControlContainer extends AbstractControlDirective {
   name: string;

modules/@angular/common/src/forms-deprecated/directives/control_value_accessor.ts

@@ -1,5 +1,4 @@
-import {OpaqueToken} from 'angular2/core';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+import {OpaqueToken} from '@angular/core';
 
 /**
  * A bridge between a control and a native element.
@@ -8,6 +7,8 @@ import {CONST_EXPR} from 'angular2/src/facade/lang';
  * DOM element representing an input control.
  *
  * Please see {@link DefaultValueAccessor} for more information.
+ *
+ * @experimental
  */
 export interface ControlValueAccessor {
   /**
@@ -30,5 +31,7 @@ export interface ControlValueAccessor {
  * Used to provide a {@link ControlValueAccessor} for form controls.
  *
  * See {@link DefaultValueAccessor} for how to implement one.
+ * @experimental
  */
-export const NG_VALUE_ACCESSOR: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValueAccessor"));
+export const NG_VALUE_ACCESSOR: OpaqueToken =
+    /*@ts2dart_const*/ new OpaqueToken('NgValueAccessor');

modules/@angular/common/src/forms-deprecated/directives/default_value_accessor.ts

@@ -1,9 +1,15 @@
-import {Directive, ElementRef, Renderer, Self, forwardRef, Provider} from 'angular2/core';
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {isBlank, CONST_EXPR} from 'angular2/src/facade/lang';
+import {Directive, ElementRef, Renderer, forwardRef} from '@angular/core';
 
-const DEFAULT_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => DefaultValueAccessor), multi: true}));
+import {isBlank} from '../../facade/lang';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+
+export const DEFAULT_VALUE_ACCESSOR: any = /*@ts2dart_const*/
+    /* @ts2dart_Provider */ {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => DefaultValueAccessor),
+      multi: true
+    };
 
 /**
  * The default accessor for writing a value and listening to changes that is used by the
@@ -13,6 +19,8 @@ const DEFAULT_VALUE_ACCESSOR = CONST_EXPR(new Provider(
  *  ```
  *  <input type="text" ngControl="searchQuery">
  *  ```
+ *
+ *  @experimental
  */
 @Directive({
   selector:
@@ -21,7 +29,7 @@ const DEFAULT_VALUE_ACCESSOR = CONST_EXPR(new Provider(
   // https://github.com/angular/angular/issues/3011 is implemented
   // selector: '[ngControl],[ngModel],[ngFormControl]',
   host: {'(input)': 'onChange($event.target.value)', '(blur)': 'onTouched()'},
-  bindings: [DEFAULT_VALUE_ACCESSOR]
+  providers: [DEFAULT_VALUE_ACCESSOR]
 })
 export class DefaultValueAccessor implements ControlValueAccessor {
   onChange = (_: any) => {};

modules/@angular/common/src/forms-deprecated/directives/form_interface.ts

@@ -1,11 +1,15 @@
+import {Control, ControlGroup} from '../model';
+
 import {NgControl} from './ng_control';
 import {NgControlGroup} from './ng_control_group';
-import {Control, ControlGroup} from '../model';
+
 
 /**
  * An interface that {@link NgFormModel} and {@link NgForm} implement.
  *
  * Only used by the forms module.
+ *
+ * @experimental
  */
 export interface Form {
   /**

modules/@angular/common/src/forms-deprecated/directives/ng_control.ts

@@ -0,0 +1,24 @@
+import {unimplemented} from '../../facade/exceptions';
+
+import {AbstractControlDirective} from './abstract_control_directive';
+import {ControlValueAccessor} from './control_value_accessor';
+import {AsyncValidatorFn, ValidatorFn} from './validators';
+
+
+/**
+ * A base class that all control directive extend.
+ * It binds a {@link Control} object to a DOM element.
+ *
+ * Used internally by Angular forms.
+ *
+ * @experimental
+ */
+export abstract class NgControl extends AbstractControlDirective {
+  name: string = null;
+  valueAccessor: ControlValueAccessor = null;
+
+  get validator(): ValidatorFn { return <ValidatorFn>unimplemented(); }
+  get asyncValidator(): AsyncValidatorFn { return <AsyncValidatorFn>unimplemented(); }
+
+  abstract viewToModelUpdate(newValue: any): void;
+}

modules/@angular/common/src/forms-deprecated/directives/ng_control_group.ts

@@ -1,26 +1,18 @@
-import {
-  OnInit,
-  OnDestroy,
-  Directive,
-  Optional,
-  Inject,
-  Host,
-  SkipSelf,
-  forwardRef,
-  Provider,
-  Self
-} from 'angular2/core';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+import {Directive, Host, Inject, OnDestroy, OnInit, Optional, Self, SkipSelf, forwardRef} from '@angular/core';
+
+import {ControlGroup} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../validators';
 
 import {ControlContainer} from './control_container';
-import {controlPath, composeValidators, composeAsyncValidators} from './shared';
-import {ControlGroup} from '../model';
 import {Form} from './form_interface';
-import {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
+import {composeAsyncValidators, composeValidators, controlPath} from './shared';
 import {AsyncValidatorFn, ValidatorFn} from './validators';
 
-const controlGroupProvider =
-    CONST_EXPR(new Provider(ControlContainer, {useExisting: forwardRef(() => NgControlGroup)}));
+export const controlGroupProvider: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: ControlContainer,
+      useExisting: forwardRef(() => NgControlGroup)
+    };
 
 /**
  * Creates and binds a control group to a DOM element.
@@ -32,12 +24,11 @@ const controlGroupProvider =
  * ```typescript
  * @Component({
  *   selector: 'my-app',
- *   directives: [FORM_DIRECTIVES],
  *   template: `
  *     <div>
- *       <h2>Angular2 Control &amp; ControlGroup Example</h2>
+ *       <h2>Angular Control &amp; ControlGroup Example</h2>
  *       <form #f="ngForm">
- *         <div ngControlGroup="name" #cg-name="form">
+ *         <div ngControlGroup="name" #cgName="ngForm">
  *           <h3>Enter your name:</h3>
  *           <p>First: <input ngControl="first" required></p>
  *           <p>Middle: <input ngControl="middle"></p>
@@ -52,8 +43,7 @@ const controlGroupProvider =
  *         <pre>{{valueOf(f)}}</pre>
  *       </form>
  *     </div>
- *   `,
- *   directives: [FORM_DIRECTIVES]
+ *   `
  * })
  * export class App {
  *   valueOf(cg: NgControlGroup): string {
@@ -67,6 +57,8 @@ const controlGroupProvider =
  *
  * This example declares a control group for a user's name. The value and validation state of
  * this group can be accessed separately from the overall form.
+ *
+ * @experimental
  */
 @Directive({
   selector: '[ngControlGroup]',
@@ -79,7 +71,8 @@ export class NgControlGroup extends ControlContainer implements OnInit,
   /** @internal */
   _parent: ControlContainer;
 
-  constructor(@Host() @SkipSelf() parent: ControlContainer,
+  constructor(
+      @Host() @SkipSelf() parent: ControlContainer,
       @Optional() @Self() @Inject(NG_VALIDATORS) private _validators: any[],
       @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) private _asyncValidators: any[]) {
     super();

modules/@angular/common/src/forms-deprecated/directives/ng_control_name.ts

@@ -1,38 +1,21 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
+import {Directive, Host, Inject, OnChanges, OnDestroy, Optional, Self, SimpleChanges, SkipSelf, forwardRef} from '@angular/core';
 
-import {
-  OnChanges,
-  OnDestroy,
-  SimpleChange,
-  Query,
-  Directive,
-  forwardRef,
-  Host,
-  SkipSelf,
-  Provider,
-  Inject,
-  Optional,
-  Self
-} from 'angular2/core';
+import {EventEmitter, ObservableWrapper} from '../../facade/async';
+import {Control} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../validators';
 
 import {ControlContainer} from './control_container';
-import {NgControl} from './ng_control';
 import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
-import {
-  controlPath,
-  composeValidators,
-  composeAsyncValidators,
-  isPropertyUpdated,
-  selectValueAccessor
-} from './shared';
-import {Control} from '../model';
-import {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
-import {ValidatorFn, AsyncValidatorFn} from './validators';
+import {NgControl} from './ng_control';
+import {composeAsyncValidators, composeValidators, controlPath, isPropertyUpdated, selectValueAccessor} from './shared';
+import {AsyncValidatorFn, ValidatorFn} from './validators';
 
 
-const controlNameBinding =
-    CONST_EXPR(new Provider(NgControl, {useExisting: forwardRef(() => NgControlName)}));
+export const controlNameBinding: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: NgControl,
+      useExisting: forwardRef(() => NgControlName)
+    };
 
 /**
  * Creates and binds a control with a specified name to a DOM element.
@@ -51,7 +34,7 @@ const controlNameBinding =
  *      directives: [FORM_DIRECTIVES],
  *      template: `
  *        <form #f="ngForm" (submit)='onLogIn(f.value)'>
- *          Login <input type='text' ngControl='login' #l="form">
+ *          Login <input type='text' ngControl='login' #l="ngForm">
  *          <div *ngIf="!l.valid">Login is invalid</div>
  *
  *          Password <input type='password' ngControl='password'>
@@ -88,10 +71,12 @@ const controlNameBinding =
  *  }
  * }
  *  ```
+ *
+ *  @experimental
  */
 @Directive({
   selector: '[ngControl]',
-  bindings: [controlNameBinding],
+  providers: [controlNameBinding],
   inputs: ['name: ngControl', 'model: ngModel'],
   outputs: ['update: ngModelChange'],
   exportAs: 'ngForm'
@@ -115,7 +100,7 @@ export class NgControlName extends NgControl implements OnChanges,
                 this.valueAccessor = selectValueAccessor(this, valueAccessors);
               }
 
-  ngOnChanges(changes: {[key: string]: SimpleChange}) {
+              ngOnChanges(changes: SimpleChanges) {
                 if (!this._added) {
                   this.formDirective.addControl(this);
                   this._added = true;
@@ -139,7 +124,9 @@ export class NgControlName extends NgControl implements OnChanges,
 
               get validator(): ValidatorFn { return composeValidators(this._validators); }
 
-  get asyncValidator(): AsyncValidatorFn { return composeAsyncValidators(this._asyncValidators); }
+              get asyncValidator(): AsyncValidatorFn {
+                return composeAsyncValidators(this._asyncValidators);
+              }
 
               get control(): Control { return this.formDirective.getControl(this); }
 }

modules/@angular/common/src/forms-deprecated/directives/ng_control_status.ts

@@ -1,10 +1,15 @@
-import {Directive, Self} from 'angular2/core';
+import {Directive, Self} from '@angular/core';
+
+import {isPresent} from '../../facade/lang';
+
 import {NgControl} from './ng_control';
-import {isBlank, isPresent} from 'angular2/src/facade/lang';
+
 
 /**
  * Directive automatically applied to Angular forms that sets CSS classes
  * based on control status (valid/invalid/dirty/etc).
+ *
+ * @experimental
  */
 @Directive({
   selector: '[ngControl],[ngModel],[ngFormControl]',

modules/@angular/common/src/forms-deprecated/directives/ng_form.ts

@@ -1,22 +1,21 @@
-import {
-  PromiseWrapper,
-  ObservableWrapper,
-  EventEmitter,
-  PromiseCompleter
-} from 'angular2/src/facade/async';
-import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
-import {isPresent, isBlank, CONST_EXPR} from 'angular2/src/facade/lang';
-import {Directive, forwardRef, Provider, Optional, Inject, Self} from 'angular2/core';
-import {NgControl} from './ng_control';
-import {Form} from './form_interface';
-import {NgControlGroup} from './ng_control_group';
-import {ControlContainer} from './control_container';
-import {AbstractControl, ControlGroup, Control} from '../model';
-import {setUpControl, setUpControlGroup, composeValidators, composeAsyncValidators} from './shared';
-import {Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
+import {Directive, Inject, Optional, Self, forwardRef} from '@angular/core';
 
-const formDirectiveProvider =
-    CONST_EXPR(new Provider(ControlContainer, {useExisting: forwardRef(() => NgForm)}));
+import {EventEmitter, ObservableWrapper, PromiseWrapper} from '../../facade/async';
+import {ListWrapper} from '../../facade/collection';
+import {isPresent} from '../../facade/lang';
+import {AbstractControl, Control, ControlGroup} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../validators';
+
+import {ControlContainer} from './control_container';
+import {Form} from './form_interface';
+import {NgControl} from './ng_control';
+import {NgControlGroup} from './ng_control_group';
+import {composeAsyncValidators, composeValidators, setUpControl, setUpControlGroup} from './shared';
+
+export const formDirectiveProvider: any =
+    /*@ts2dart_const*/ {provide: ControlContainer, useExisting: forwardRef(() => NgForm)};
+
+let _formWarningDisplayed: boolean = false;
 
 /**
  * If `NgForm` is bound in a component, `<form>` elements in that component will be
@@ -76,10 +75,13 @@ const formDirectiveProvider =
  *   }
  * }
  *  ```
+ *
+ *  @experimental
  */
+
 @Directive({
   selector: 'form:not([ngNoForm]):not([ngFormModel]),ngForm,[ngForm]',
-  bindings: [formDirectiveProvider],
+  providers: [formDirectiveProvider],
   host: {
     '(submit)': 'onSubmit()',
   },
@@ -87,16 +89,34 @@ const formDirectiveProvider =
   exportAs: 'ngForm'
 })
 export class NgForm extends ControlContainer implements Form {
+  private _submitted: boolean = false;
+
   form: ControlGroup;
   ngSubmit = new EventEmitter();
 
-  constructor(@Optional() @Self() @Inject(NG_VALIDATORS) validators: any[],
+  constructor(
+      @Optional() @Self() @Inject(NG_VALIDATORS) validators: any[],
       @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) asyncValidators: any[]) {
     super();
-    this.form = new ControlGroup({}, null, composeValidators(validators),
-                                 composeAsyncValidators(asyncValidators));
+    this._displayWarning();
+    this.form = new ControlGroup(
+        {}, null, composeValidators(validators), composeAsyncValidators(asyncValidators));
   }
 
+  private _displayWarning() {
+    // TODO(kara): Update this when the new forms module becomes the default
+    if (!_formWarningDisplayed) {
+      _formWarningDisplayed = true;
+      console.warn(`
+      *It looks like you're using the old forms module. This will be opt-in in the next RC, and
+      will eventually be removed in favor of the new forms module. For more information, see:
+      https://docs.google.com/document/u/1/d/1RIezQqE4aEhBRmArIAS1mRIZtWFf6JxN_7B4meyWK0Y/pub
+    `);
+    }
+  }
+
+  get submitted(): boolean { return this._submitted; }
+
   get formDirective(): Form { return this; }
 
   get control(): ControlGroup { return this.form; }
@@ -110,7 +130,7 @@ export class NgForm extends ControlContainer implements Form {
       var container = this._findContainer(dir.path);
       var ctrl = new Control();
       setUpControl(ctrl, dir);
-      container.addControl(dir.name, ctrl);
+      container.registerControl(dir.name, ctrl);
       ctrl.updateValueAndValidity({emitEvent: false});
     });
   }
@@ -122,7 +142,6 @@ export class NgForm extends ControlContainer implements Form {
       var container = this._findContainer(dir.path);
       if (isPresent(container)) {
         container.removeControl(dir.name);
-        container.updateValueAndValidity({emitEvent: false});
       }
     });
   }
@@ -132,7 +151,7 @@ export class NgForm extends ControlContainer implements Form {
       var container = this._findContainer(dir.path);
       var group = new ControlGroup({});
       setUpControlGroup(group, dir);
-      container.addControl(dir.name, group);
+      container.registerControl(dir.name, group);
       group.updateValueAndValidity({emitEvent: false});
     });
   }
@@ -142,7 +161,6 @@ export class NgForm extends ControlContainer implements Form {
       var container = this._findContainer(dir.path);
       if (isPresent(container)) {
         container.removeControl(dir.name);
-        container.updateValueAndValidity({emitEvent: false});
       }
     });
   }
@@ -159,6 +177,7 @@ export class NgForm extends ControlContainer implements Form {
   }
 
   onSubmit(): boolean {
+    this._submitted = true;
     ObservableWrapper.callEmit(this.ngSubmit, null);
     return false;
   }

modules/@angular/common/src/forms-deprecated/directives/ng_form_control.ts

@@ -1,32 +1,20 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {StringMapWrapper} from 'angular2/src/facade/collection';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
-import {
-  OnChanges,
-  SimpleChange,
-  Query,
-  Directive,
-  forwardRef,
-  Provider,
-  Inject,
-  Optional,
-  Self
-} from 'angular2/core';
-import {NgControl} from './ng_control';
-import {Control} from '../model';
-import {Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
-import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
-import {
-  setUpControl,
-  composeValidators,
-  composeAsyncValidators,
-  isPropertyUpdated,
-  selectValueAccessor
-} from './shared';
-import {ValidatorFn, AsyncValidatorFn} from './validators';
+import {Directive, Inject, OnChanges, Optional, Self, SimpleChanges, forwardRef} from '@angular/core';
 
-const formControlBinding =
-    CONST_EXPR(new Provider(NgControl, {useExisting: forwardRef(() => NgFormControl)}));
+import {EventEmitter, ObservableWrapper} from '../../facade/async';
+import {StringMapWrapper} from '../../facade/collection';
+import {Control} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../validators';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+import {NgControl} from './ng_control';
+import {composeAsyncValidators, composeValidators, isPropertyUpdated, selectValueAccessor, setUpControl} from './shared';
+import {AsyncValidatorFn, ValidatorFn} from './validators';
+
+export const formControlBinding: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: NgControl,
+      useExisting: forwardRef(() => NgFormControl)
+    };
 
 /**
  * Binds an existing {@link Control} to a DOM element.
@@ -74,10 +62,12 @@ const formControlBinding =
  *  login:string;
  * }
  *  ```
+ *
+ *  @experimental
  */
 @Directive({
   selector: '[ngFormControl]',
-  bindings: [formControlBinding],
+  providers: [formControlBinding],
   inputs: ['form: ngFormControl', 'model: ngModel'],
   outputs: ['update: ngModelChange'],
   exportAs: 'ngForm'
@@ -98,7 +88,7 @@ export class NgFormControl extends NgControl implements OnChanges {
                 this.valueAccessor = selectValueAccessor(this, valueAccessors);
               }
 
-  ngOnChanges(changes: {[key: string]: SimpleChange}): void {
+              ngOnChanges(changes: SimpleChanges): void {
                 if (this._isControlChanged(changes)) {
                   setUpControl(this.form, this);
                   this.form.updateValueAndValidity({emitEvent: false});
@@ -113,7 +103,9 @@ export class NgFormControl extends NgControl implements OnChanges {
 
               get validator(): ValidatorFn { return composeValidators(this._validators); }
 
-  get asyncValidator(): AsyncValidatorFn { return composeAsyncValidators(this._asyncValidators); }
+              get asyncValidator(): AsyncValidatorFn {
+                return composeAsyncValidators(this._asyncValidators);
+              }
 
               get control(): Control { return this.form; }
 
@@ -123,6 +115,6 @@ export class NgFormControl extends NgControl implements OnChanges {
               }
 
               private _isControlChanged(changes: {[key: string]: any}): boolean {
-    return StringMapWrapper.contains(changes, "form");
+                return StringMapWrapper.contains(changes, 'form');
               }
 }

modules/@angular/common/src/forms-deprecated/directives/ng_form_model.ts

@@ -1,26 +1,25 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
-import {ObservableWrapper, EventEmitter} from 'angular2/src/facade/async';
-import {
-  SimpleChange,
-  OnChanges,
-  Directive,
-  forwardRef,
-  Provider,
-  Inject,
-  Optional,
-  Self
-} from 'angular2/core';
-import {NgControl} from './ng_control';
-import {NgControlGroup} from './ng_control_group';
+import {Directive, Inject, OnChanges, Optional, Self, SimpleChanges, forwardRef} from '@angular/core';
+
+import {EventEmitter, ObservableWrapper} from '../../facade/async';
+import {ListWrapper, StringMapWrapper} from '../../facade/collection';
+import {BaseException} from '../../facade/exceptions';
+import {isBlank} from '../../facade/lang';
+import {Control, ControlGroup} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS, Validators} from '../validators';
+
 import {ControlContainer} from './control_container';
 import {Form} from './form_interface';
-import {Control, ControlGroup} from '../model';
-import {setUpControl, setUpControlGroup, composeValidators, composeAsyncValidators} from './shared';
-import {Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
+import {NgControl} from './ng_control';
+import {NgControlGroup} from './ng_control_group';
+import {composeAsyncValidators, composeValidators, setUpControl, setUpControlGroup} from './shared';
 
-const formDirectiveProvider =
-    CONST_EXPR(new Provider(ControlContainer, {useExisting: forwardRef(() => NgFormModel)}));
+export const formDirectiveProvider: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: ControlContainer,
+      useExisting: forwardRef(() => NgFormModel)
+    };
+
+let _formModelWarningDisplayed: boolean = false;
 
 /**
  * Binds an existing control group to a DOM element.
@@ -93,10 +92,13 @@ const formDirectiveProvider =
  *  }
  * }
  *  ```
+ *
+ *  @experimental
  */
+
 @Directive({
   selector: '[ngFormModel]',
-  bindings: [formDirectiveProvider],
+  providers: [formDirectiveProvider],
   inputs: ['form: ngFormModel'],
   host: {'(submit)': 'onSubmit()'},
   outputs: ['ngSubmit'],
@@ -104,17 +106,34 @@ const formDirectiveProvider =
 })
 export class NgFormModel extends ControlContainer implements Form,
     OnChanges {
+  private _submitted: boolean = false;
+
   form: ControlGroup = null;
   directives: NgControl[] = [];
   ngSubmit = new EventEmitter();
 
-  constructor(@Optional() @Self() @Inject(NG_VALIDATORS) private _validators: any[],
+  constructor(
+      @Optional() @Self() @Inject(NG_VALIDATORS) private _validators: any[],
       @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) private _asyncValidators: any[]) {
     super();
+    this._displayWarning();
   }
 
-  ngOnChanges(changes: {[key: string]: SimpleChange}): void {
-    if (StringMapWrapper.contains(changes, "form")) {
+  private _displayWarning() {
+    // TODO(kara): Update this when the new forms module becomes the default
+    if (!_formModelWarningDisplayed) {
+      _formModelWarningDisplayed = true;
+      console.warn(`
+      *It looks like you're using the old forms module. This will be opt-in in the next RC, and
+      will eventually be removed in favor of the new forms module. For more information, see:
+      https://docs.google.com/document/u/1/d/1RIezQqE4aEhBRmArIAS1mRIZtWFf6JxN_7B4meyWK0Y/pub
+    `);
+    }
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    this._checkFormPresent();
+    if (StringMapWrapper.contains(changes, 'form')) {
       var sync = composeValidators(this._validators);
       this.form.validator = Validators.compose([this.form.validator, sync]);
 
@@ -127,6 +146,8 @@ export class NgFormModel extends ControlContainer implements Form,
     this._updateDomValue();
   }
 
+  get submitted(): boolean { return this._submitted; }
+
   get formDirective(): Form { return this; }
 
   get control(): ControlGroup { return this.form; }
@@ -162,6 +183,7 @@ export class NgFormModel extends ControlContainer implements Form,
   }
 
   onSubmit(): boolean {
+    this._submitted = true;
     ObservableWrapper.callEmit(this.ngSubmit, null);
     return false;
   }
@@ -173,4 +195,11 @@ export class NgFormModel extends ControlContainer implements Form,
       dir.valueAccessor.writeValue(ctrl.value);
     });
   }
+
+  private _checkFormPresent() {
+    if (isBlank(this.form)) {
+      throw new BaseException(
+          `ngFormModel expects a form. Please pass one in. Example: <form [ngFormModel]="myCoolForm">`);
+    }
+  }
 }

modules/@angular/common/src/forms-deprecated/directives/ng_model.ts

@@ -0,0 +1,92 @@
+import {Directive, Inject, OnChanges, Optional, Self, SimpleChanges, forwardRef} from '@angular/core';
+
+import {EventEmitter, ObservableWrapper} from '../../facade/async';
+import {Control} from '../model';
+import {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../validators';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+import {NgControl} from './ng_control';
+import {composeAsyncValidators, composeValidators, isPropertyUpdated, selectValueAccessor, setUpControl} from './shared';
+import {AsyncValidatorFn, ValidatorFn} from './validators';
+
+export const formControlBinding: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: NgControl,
+      useExisting: forwardRef(() => NgModel)
+    };
+
+/**
+ * Binds a domain model to a form control.
+ *
+ * ### Usage
+ *
+ * `ngModel` binds an existing domain model to a form control. For a
+ * two-way binding, use `[(ngModel)]` to ensure the model updates in
+ * both directions.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/R3UX5qDaUqFO2VYR0UzH?p=preview))
+ *  ```typescript
+ * @Component({
+ *      selector: "search-comp",
+ *      directives: [FORM_DIRECTIVES],
+ *      template: `<input type='text' [(ngModel)]="searchQuery">`
+ *      })
+ * class SearchComp {
+ *  searchQuery: string;
+ * }
+ *  ```
+ *
+ *  @experimental
+ */
+@Directive({
+  selector: '[ngModel]:not([ngControl]):not([ngFormControl])',
+  providers: [formControlBinding],
+  inputs: ['model: ngModel'],
+  outputs: ['update: ngModelChange'],
+  exportAs: 'ngForm'
+})
+export class NgModel extends NgControl implements OnChanges {
+  /** @internal */
+  _control = new Control();
+  /** @internal */
+  _added = false;
+  update = new EventEmitter();
+  model: any;
+  viewModel: any;
+
+  constructor(@Optional() @Self() @Inject(NG_VALIDATORS) private _validators: any[],
+              @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) private _asyncValidators: any[],
+              @Optional() @Self() @Inject(NG_VALUE_ACCESSOR)
+              valueAccessors: ControlValueAccessor[]) {
+                super();
+                this.valueAccessor = selectValueAccessor(this, valueAccessors);
+              }
+
+              ngOnChanges(changes: SimpleChanges) {
+                if (!this._added) {
+                  setUpControl(this._control, this);
+                  this._control.updateValueAndValidity({emitEvent: false});
+                  this._added = true;
+                }
+
+                if (isPropertyUpdated(changes, this.viewModel)) {
+                  this._control.updateValue(this.model);
+                  this.viewModel = this.model;
+                }
+              }
+
+              get control(): Control { return this._control; }
+
+              get path(): string[] { return []; }
+
+              get validator(): ValidatorFn { return composeValidators(this._validators); }
+
+              get asyncValidator(): AsyncValidatorFn {
+                return composeAsyncValidators(this._asyncValidators);
+              }
+
+              viewToModelUpdate(newValue: any): void {
+                this.viewModel = newValue;
+                ObservableWrapper.callEmit(this.update, newValue);
+              }
+}

modules/@angular/common/src/forms-deprecated/directives/normalize_validator.ts

@@ -1,5 +1,6 @@
-import {AbstractControl} from "../model";
-import {Validator, ValidatorFn, AsyncValidatorFn} from './validators';
+import {AbstractControl} from '../model';
+
+import {AsyncValidatorFn, Validator, ValidatorFn} from './validators';
 
 export function normalizeValidator(validator: ValidatorFn | Validator): ValidatorFn {
   if ((<Validator>validator).validate !== undefined) {

modules/@angular/common/src/forms-deprecated/directives/number_value_accessor.ts

@@ -1,9 +1,14 @@
-import {Directive, ElementRef, Renderer, Self, forwardRef, Provider} from 'angular2/core';
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {isBlank, CONST_EXPR, NumberWrapper} from 'angular2/src/facade/lang';
+import {Directive, ElementRef, Renderer, forwardRef} from '@angular/core';
 
-const NUMBER_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => NumberValueAccessor), multi: true}));
+import {NumberWrapper} from '../../facade/lang';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+
+export const NUMBER_VALUE_ACCESSOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => NumberValueAccessor),
+  multi: true
+};
 
 /**
  * The accessor for writing a number value and listening to changes that is used by the
@@ -22,7 +27,7 @@ const NUMBER_VALUE_ACCESSOR = CONST_EXPR(new Provider(
     '(input)': 'onChange($event.target.value)',
     '(blur)': 'onTouched()'
   },
-  bindings: [NUMBER_VALUE_ACCESSOR]
+  providers: [NUMBER_VALUE_ACCESSOR]
 })
 export class NumberValueAccessor implements ControlValueAccessor {
   onChange = (_: any) => {};
@@ -35,7 +40,7 @@ export class NumberValueAccessor implements ControlValueAccessor {
   }
 
   registerOnChange(fn: (_: number) => void): void {
-    this.onChange = (value) => { fn(NumberWrapper.parseFloat(value)); };
+    this.onChange = (value) => { fn(value == '' ? null : NumberWrapper.parseFloat(value)); };
   }
   registerOnTouched(fn: () => void): void { this.onTouched = fn; }
 }

modules/@angular/common/src/forms-deprecated/directives/radio_control_value_accessor.ts

@@ -1,28 +1,16 @@
-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';
+import {Directive, ElementRef, Injectable, Injector, Input, OnDestroy, OnInit, Renderer, forwardRef} from '@angular/core';
 
-const RADIO_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => RadioControlValueAccessor), multi: true}));
+import {ListWrapper} from '../../facade/collection';
+import {isPresent} from '../../facade/lang';
 
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+import {NgControl} from './ng_control';
+
+export const RADIO_VALUE_ACCESSOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => RadioControlValueAccessor),
+  multi: true
+};
 
 /**
  * Internal class used by Angular to uncheck radio buttons with the matching name.
@@ -47,15 +35,23 @@ export class RadioControlRegistry {
 
   select(accessor: RadioControlValueAccessor) {
     this._accessors.forEach((c) => {
-      if (c[0].control.root === accessor._control.control.root && c[1] !== accessor) {
+      if (this._isSameGroup(c, accessor) && c[1] !== accessor) {
         c[1].fireUncheck();
       }
     });
   }
+
+  private _isSameGroup(
+      controlPair: [NgControl, RadioControlValueAccessor], accessor: RadioControlValueAccessor) {
+    return controlPair[0].control.root === accessor._control.control.root &&
+        controlPair[1].name === accessor.name;
+  }
 }
 
 /**
  * The value provided by the forms API for radio buttons.
+ *
+ * @experimental
  */
 export class RadioButtonState {
   constructor(public checked: boolean, public value: string) {}
@@ -88,14 +84,18 @@ export class RadioButtonState {
 })
 export class RadioControlValueAccessor implements ControlValueAccessor,
     OnDestroy, OnInit {
+  /** @internal */
   _state: RadioButtonState;
+  /** @internal */
   _control: NgControl;
   @Input() name: string;
+  /** @internal */
   _fn: Function;
   onChange = () => {};
   onTouched = () => {};
 
-  constructor(private _renderer: Renderer, private _elementRef: ElementRef,
+  constructor(
+      private _renderer: Renderer, private _elementRef: ElementRef,
       private _registry: RadioControlRegistry, private _injector: Injector) {}
 
   ngOnInit(): void {

modules/@angular/common/src/forms-deprecated/directives/select_control_value_accessor.ts

@@ -0,0 +1,132 @@
+import {Directive, ElementRef, Host, Input, OnDestroy, Optional, Renderer, forwardRef} from '@angular/core';
+
+import {MapWrapper} from '../../facade/collection';
+import {StringWrapper, isBlank, isPresent, isPrimitive, looseIdentical} from '../../facade/lang';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+
+export const SELECT_VALUE_ACCESSOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => SelectControlValueAccessor),
+  multi: true
+};
+
+function _buildValueString(id: string, value: any): string {
+  if (isBlank(id)) return `${value}`;
+  if (!isPrimitive(value)) value = 'Object';
+  return StringWrapper.slice(`${id}: ${value}`, 0, 50);
+}
+
+function _extractId(valueString: string): string {
+  return valueString.split(':')[0];
+}
+
+/**
+ * The accessor for writing a value and listening to changes on a select element.
+ *
+ * Note: We have to listen to the 'change' event because 'input' events aren't fired
+ * for selects in Firefox and IE:
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=1024350
+ * https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/4660045/
+ *
+ * @experimental
+ */
+@Directive({
+  selector:
+      'select:not([multiple])[ngControl],select:not([multiple])[ngFormControl],select:not([multiple])[ngModel]',
+  host: {'(change)': 'onChange($event.target.value)', '(blur)': 'onTouched()'},
+  providers: [SELECT_VALUE_ACCESSOR]
+})
+export class SelectControlValueAccessor implements ControlValueAccessor {
+  value: any;
+  /** @internal */
+  _optionMap: Map<string, any> = new Map<string, any>();
+  /** @internal */
+  _idCounter: number = 0;
+
+  onChange = (_: any) => {};
+  onTouched = () => {};
+
+  constructor(private _renderer: Renderer, private _elementRef: ElementRef) {}
+
+  writeValue(value: any): void {
+    this.value = value;
+    var valueString = _buildValueString(this._getOptionId(value), value);
+    this._renderer.setElementProperty(this._elementRef.nativeElement, 'value', valueString);
+  }
+
+  registerOnChange(fn: (value: any) => any): void {
+    this.onChange = (valueString: string) => {
+      this.value = valueString;
+      fn(this._getOptionValue(valueString));
+    };
+  }
+  registerOnTouched(fn: () => any): void { this.onTouched = fn; }
+
+  /** @internal */
+  _registerOption(): string { return (this._idCounter++).toString(); }
+
+  /** @internal */
+  _getOptionId(value: any): string {
+    for (let id of MapWrapper.keys(this._optionMap)) {
+      if (looseIdentical(this._optionMap.get(id), value)) return id;
+    }
+    return null;
+  }
+
+  /** @internal */
+  _getOptionValue(valueString: string): any {
+    let value = this._optionMap.get(_extractId(valueString));
+    return isPresent(value) ? value : valueString;
+  }
+}
+
+/**
+ * Marks `<option>` as dynamic, so Angular can be notified when options change.
+ *
+ * ### Example
+ *
+ * ```
+ * <select ngControl="city">
+ *   <option *ngFor="let c of cities" [value]="c"></option>
+ * </select>
+ * ```
+ *
+ * @experimental
+ */
+@Directive({selector: 'option'})
+export class NgSelectOption implements OnDestroy {
+  id: string;
+
+  constructor(
+      private _element: ElementRef, private _renderer: Renderer,
+      @Optional() @Host() private _select: SelectControlValueAccessor) {
+    if (isPresent(this._select)) this.id = this._select._registerOption();
+  }
+
+  @Input('ngValue')
+  set ngValue(value: any) {
+    if (this._select == null) return;
+    this._select._optionMap.set(this.id, value);
+    this._setElementValue(_buildValueString(this.id, value));
+    this._select.writeValue(this._select.value);
+  }
+
+  @Input('value')
+  set value(value: any) {
+    this._setElementValue(value);
+    if (isPresent(this._select)) this._select.writeValue(this._select.value);
+  }
+
+  /** @internal */
+  _setElementValue(value: string): void {
+    this._renderer.setElementProperty(this._element.nativeElement, 'value', value);
+  }
+
+  ngOnDestroy() {
+    if (isPresent(this._select)) {
+      this._select._optionMap.delete(this.id);
+      this._select.writeValue(this._select.value);
+    }
+  }
+}

modules/@angular/common/src/forms-deprecated/directives/select_multiple_control_value_accessor.ts

@@ -0,0 +1,177 @@
+import {Directive, ElementRef, Host, Input, OnDestroy, Optional, Renderer, forwardRef} from '@angular/core';
+
+import {MapWrapper} from '../../facade/collection';
+import {StringWrapper, isBlank, isPresent, isPrimitive, isString, looseIdentical} from '../../facade/lang';
+
+import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
+
+const SELECT_MULTIPLE_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => SelectMultipleControlValueAccessor),
+  multi: true
+};
+
+function _buildValueString(id: string, value: any): string {
+  if (isBlank(id)) return `${value}`;
+  if (isString(value)) value = `'${value}'`;
+  if (!isPrimitive(value)) value = 'Object';
+  return StringWrapper.slice(`${id}: ${value}`, 0, 50);
+}
+
+function _extractId(valueString: string): string {
+  return valueString.split(':')[0];
+}
+
+/** Mock interface for HTML Options */
+interface HTMLOption {
+  value: string;
+  selected: boolean;
+}
+
+/** Mock interface for HTMLCollection */
+abstract class HTMLCollection {
+  length: number;
+  abstract item(_: number): HTMLOption;
+}
+
+/**
+ * The accessor for writing a value and listening to changes on a select element.
+ */
+@Directive({
+  selector: 'select[multiple][ngControl],select[multiple][ngFormControl],select[multiple][ngModel]',
+  host: {'(input)': 'onChange($event.target)', '(blur)': 'onTouched()'},
+  providers: [SELECT_MULTIPLE_VALUE_ACCESSOR]
+})
+export class SelectMultipleControlValueAccessor implements ControlValueAccessor {
+  value: any;
+  /** @internal */
+  _optionMap: Map<string, NgSelectMultipleOption> = new Map<string, NgSelectMultipleOption>();
+  /** @internal */
+  _idCounter: number = 0;
+
+  onChange = (_: any) => {};
+  onTouched = () => {};
+
+  constructor() {}
+
+  writeValue(value: any): void {
+    this.value = value;
+    if (value == null) return;
+    let values: Array<any> = <Array<any>>value;
+    // convert values to ids
+    let ids = values.map((v) => this._getOptionId(v));
+    this._optionMap.forEach((opt, o) => { opt._setSelected(ids.indexOf(o.toString()) > -1); });
+  }
+
+  registerOnChange(fn: (value: any) => any): void {
+    this.onChange = (_: any) => {
+      let selected: Array<any> = [];
+      if (_.hasOwnProperty('selectedOptions')) {
+        let options: HTMLCollection = _.selectedOptions;
+        for (var i = 0; i < options.length; i++) {
+          let opt: any = options.item(i);
+          let val: any = this._getOptionValue(opt.value);
+          selected.push(val);
+        }
+      }
+      // Degrade on IE
+      else {
+        let options: HTMLCollection = <HTMLCollection>_.options;
+        for (var i = 0; i < options.length; i++) {
+          let opt: HTMLOption = options.item(i);
+          if (opt.selected) {
+            let val: any = this._getOptionValue(opt.value);
+            selected.push(val);
+          }
+        }
+      }
+      fn(selected);
+    };
+  }
+  registerOnTouched(fn: () => any): void { this.onTouched = fn; }
+
+  /** @internal */
+  _registerOption(value: NgSelectMultipleOption): string {
+    let id: string = (this._idCounter++).toString();
+    this._optionMap.set(id, value);
+    return id;
+  }
+
+  /** @internal */
+  _getOptionId(value: any): string {
+    for (let id of MapWrapper.keys(this._optionMap)) {
+      if (looseIdentical(this._optionMap.get(id)._value, value)) return id;
+    }
+    return null;
+  }
+
+  /** @internal */
+  _getOptionValue(valueString: string): any {
+    let opt = this._optionMap.get(_extractId(valueString));
+    return isPresent(opt) ? opt._value : valueString;
+  }
+}
+
+/**
+ * Marks `<option>` as dynamic, so Angular can be notified when options change.
+ *
+ * ### Example
+ *
+ * ```
+ * <select multiple ngControl="city">
+ *   <option *ngFor="let c of cities" [value]="c"></option>
+ * </select>
+ * ```
+ */
+@Directive({selector: 'option'})
+export class NgSelectMultipleOption implements OnDestroy {
+  id: string;
+  /** @internal */
+  _value: any;
+
+  constructor(
+      private _element: ElementRef, private _renderer: Renderer,
+      @Optional() @Host() private _select: SelectMultipleControlValueAccessor) {
+    if (isPresent(this._select)) {
+      this.id = this._select._registerOption(this);
+    }
+  }
+
+  @Input('ngValue')
+  set ngValue(value: any) {
+    if (this._select == null) return;
+    this._value = value;
+    this._setElementValue(_buildValueString(this.id, value));
+    this._select.writeValue(this._select.value);
+  }
+
+  @Input('value')
+  set value(value: any) {
+    if (isPresent(this._select)) {
+      this._value = value;
+      this._setElementValue(_buildValueString(this.id, value));
+      this._select.writeValue(this._select.value);
+    } else {
+      this._setElementValue(value);
+    }
+  }
+
+  /** @internal */
+  _setElementValue(value: string): void {
+    this._renderer.setElementProperty(this._element.nativeElement, 'value', value);
+  }
+
+  /** @internal */
+  _setSelected(selected: boolean) {
+    this._renderer.setElementProperty(this._element.nativeElement, 'selected', selected);
+  }
+
+  ngOnDestroy() {
+    if (isPresent(this._select)) {
+      this._select._optionMap.delete(this.id);
+      this._select.writeValue(this._select.value);
+    }
+  }
+}
+
+export const SELECT_DIRECTIVES = [SelectMultipleControlValueAccessor, NgSelectMultipleOption];

modules/@angular/common/src/forms-deprecated/directives/shared.ts

@@ -1,21 +1,21 @@
-import {ListWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
-import {isBlank, isPresent, looseIdentical, hasConstructor} from 'angular2/src/facade/lang';
-import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
-
-import {ControlContainer} from './control_container';
-import {NgControl} from './ng_control';
-import {AbstractControlDirective} from './abstract_control_directive';
-import {NgControlGroup} from './ng_control_group';
+import {ListWrapper, StringMapWrapper} from '../../facade/collection';
+import {BaseException} from '../../facade/exceptions';
+import {hasConstructor, isBlank, isPresent, looseIdentical} from '../../facade/lang';
 import {Control, ControlGroup} from '../model';
 import {Validators} from '../validators';
+
+import {AbstractControlDirective} from './abstract_control_directive';
+import {CheckboxControlValueAccessor} from './checkbox_value_accessor';
+import {ControlContainer} from './control_container';
 import {ControlValueAccessor} from './control_value_accessor';
 import {DefaultValueAccessor} from './default_value_accessor';
+import {NgControl} from './ng_control';
+import {NgControlGroup} from './ng_control_group';
+import {normalizeAsyncValidator, normalizeValidator} from './normalize_validator';
 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, normalizeAsyncValidator} from './normalize_validator';
-import {ValidatorFn, AsyncValidatorFn} from './validators';
+import {SelectControlValueAccessor} from './select_control_value_accessor';
+import {AsyncValidatorFn, ValidatorFn} from './validators';
 
 
 export function controlPath(name: string, parent: ControlContainer): string[] {
@@ -25,8 +25,8 @@ export function controlPath(name: string, parent: ControlContainer): string[] {
 }
 
 export function setUpControl(control: Control, dir: NgControl): void {
-  if (isBlank(control)) _throwError(dir, "Cannot find control");
-  if (isBlank(dir.valueAccessor)) _throwError(dir, "No value accessor for");
+  if (isBlank(control)) _throwError(dir, 'Cannot find control');
+  if (isBlank(dir.valueAccessor)) _throwError(dir, 'No value accessor for');
 
   control.validator = Validators.compose([control.validator, dir.validator]);
   control.asyncValidator = Validators.composeAsync([control.asyncValidator, dir.asyncValidator]);
@@ -47,13 +47,13 @@ export function setUpControl(control: Control, dir: NgControl): void {
 }
 
 export function setUpControlGroup(control: ControlGroup, dir: NgControlGroup) {
-  if (isBlank(control)) _throwError(dir, "Cannot find control");
+  if (isBlank(control)) _throwError(dir, 'Cannot find control');
   control.validator = Validators.compose([control.validator, dir.validator]);
   control.asyncValidator = Validators.composeAsync([control.asyncValidator, dir.asyncValidator]);
 }
 
 function _throwError(dir: AbstractControlDirective, message: string): void {
-  var path = dir.path.join(" -> ");
+  var path = dir.path.join(' -> ');
   throw new BaseException(`${message} '${path}'`);
 }
 
@@ -61,23 +61,23 @@ export function composeValidators(validators: /* Array<Validator|Function> */ an
   return isPresent(validators) ? Validators.compose(validators.map(normalizeValidator)) : null;
 }
 
-export function composeAsyncValidators(
-    validators: /* Array<Validator|Function> */ any[]): AsyncValidatorFn {
+export function composeAsyncValidators(validators: /* Array<Validator|Function> */ any[]):
+    AsyncValidatorFn {
   return isPresent(validators) ? Validators.composeAsync(validators.map(normalizeAsyncValidator)) :
                                  null;
 }
 
 export function isPropertyUpdated(changes: {[key: string]: any}, viewModel: any): boolean {
-  if (!StringMapWrapper.contains(changes, "model")) return false;
-  var change = changes["model"];
+  if (!StringMapWrapper.contains(changes, 'model')) return false;
+  var change = changes['model'];
 
   if (change.isFirstChange()) return true;
   return !looseIdentical(viewModel, change.currentValue);
 }
 
 // TODO: vsavkin remove it once https://github.com/angular/angular/issues/3011 is implemented
-export function selectValueAccessor(dir: NgControl,
-                                    valueAccessors: ControlValueAccessor[]): ControlValueAccessor {
+export function selectValueAccessor(
+    dir: NgControl, valueAccessors: ControlValueAccessor[]): ControlValueAccessor {
   if (isBlank(valueAccessors)) return null;
 
   var defaultAccessor: ControlValueAccessor;
@@ -87,17 +87,17 @@ export function selectValueAccessor(dir: NgControl,
     if (hasConstructor(v, DefaultValueAccessor)) {
       defaultAccessor = v;
 
-    } else if (hasConstructor(v, CheckboxControlValueAccessor) ||
-               hasConstructor(v, NumberValueAccessor) ||
+    } else if (
+        hasConstructor(v, CheckboxControlValueAccessor) || hasConstructor(v, NumberValueAccessor) ||
         hasConstructor(v, SelectControlValueAccessor) ||
         hasConstructor(v, RadioControlValueAccessor)) {
       if (isPresent(builtinAccessor))
-        _throwError(dir, "More than one built-in value accessor matches");
+        _throwError(dir, 'More than one built-in value accessor matches');
       builtinAccessor = v;
 
     } else {
       if (isPresent(customAccessor))
-        _throwError(dir, "More than one custom value accessor matches");
+        _throwError(dir, 'More than one custom value accessor matches');
       customAccessor = v;
     }
   });
@@ -106,6 +106,6 @@ export function selectValueAccessor(dir: NgControl,
   if (isPresent(builtinAccessor)) return builtinAccessor;
   if (isPresent(defaultAccessor)) return defaultAccessor;
 
-  _throwError(dir, "No valid value accessor for");
+  _throwError(dir, 'No valid value accessor for');
   return null;
 }

modules/@angular/common/src/forms-deprecated/directives/validators.ts

@@ -1,9 +1,8 @@
-import {forwardRef, Provider, Attribute, Directive} from 'angular2/core';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {Validators, NG_VALIDATORS} from '../validators';
+import {Attribute, Directive, forwardRef} from '@angular/core';
+
+import {NumberWrapper} from '../../facade/lang';
 import {AbstractControl} from '../model';
-import * as modelModule from '../model';
-import {NumberWrapper} from "angular2/src/facade/lang";
+import {NG_VALIDATORS, Validators} from '../validators';
 
 
 
@@ -15,7 +14,7 @@ import {NumberWrapper} from "angular2/src/facade/lang";
  * ```typescript
  * @Directive({
  *   selector: '[custom-validator]',
- *   providers: [provide(NG_VALIDATORS, {useExisting: CustomValidatorDirective, multi: true})]
+ *   providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]
  * })
  * class CustomValidatorDirective implements Validator {
  *   validate(c: Control): {[key: string]: any} {
@@ -24,10 +23,15 @@ import {NumberWrapper} from "angular2/src/facade/lang";
  * }
  * ```
  */
-export interface Validator { validate(c: modelModule.AbstractControl): {[key: string]: any}; }
+export interface Validator { validate(c: AbstractControl): {[key: string]: any}; }
 
-const REQUIRED_VALIDATOR =
-    CONST_EXPR(new Provider(NG_VALIDATORS, {useValue: Validators.required, multi: true}));
+const REQUIRED = /*@ts2dart_const*/ Validators.required;
+
+export const REQUIRED_VALIDATOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALIDATORS,
+  useValue: REQUIRED,
+  multi: true
+};
 
 /**
  * A Directive that adds the `required` validator to any controls marked with the
@@ -38,6 +42,8 @@ const REQUIRED_VALIDATOR =
  * ```
  * <input ngControl="fullName" required>
  * ```
+ *
+ * @experimental
  */
 @Directive({
   selector: '[required][ngControl],[required][ngFormControl],[required][ngModel]',
@@ -58,12 +64,17 @@ export interface AsyncValidatorFn {
  *
  * {@example common/forms/ts/validators/validators.ts region='min'}
  */
-const MIN_LENGTH_VALIDATOR = CONST_EXPR(
-    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MinLengthValidator), multi: true}));
+export const MIN_LENGTH_VALIDATOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MinLengthValidator),
+  multi: true
+};
 
 /**
  * A directive which installs the {@link MinLengthValidator} for any `ngControl`,
  * `ngFormControl`, or control with `ngModel` that also has a `minlength` attribute.
+ *
+ * @experimental
  */
 @Directive({
   selector: '[minlength][ngControl],[minlength][ngFormControl],[minlength][ngModel]',
@@ -72,7 +83,7 @@ const MIN_LENGTH_VALIDATOR = CONST_EXPR(
 export class MinLengthValidator implements Validator {
   private _validator: ValidatorFn;
 
-  constructor(@Attribute("minlength") minLength: string) {
+  constructor(@Attribute('minlength') minLength: string) {
     this._validator = Validators.minLength(NumberWrapper.parseInt(minLength, 10));
   }
 
@@ -86,12 +97,17 @@ export class MinLengthValidator implements Validator {
  *
  * {@example common/forms/ts/validators/validators.ts region='max'}
  */
-const MAX_LENGTH_VALIDATOR = CONST_EXPR(
-    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => MaxLengthValidator), multi: true}));
+export const MAX_LENGTH_VALIDATOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MaxLengthValidator),
+  multi: true
+};
 
 /**
  * A directive which installs the {@link MaxLengthValidator} for any `ngControl, `ngFormControl`,
  * or control with `ngModel` that also has a `maxlength` attribute.
+ *
+ * @experimental
  */
 @Directive({
   selector: '[maxlength][ngControl],[maxlength][ngFormControl],[maxlength][ngModel]',
@@ -100,7 +116,7 @@ const MAX_LENGTH_VALIDATOR = CONST_EXPR(
 export class MaxLengthValidator implements Validator {
   private _validator: ValidatorFn;
 
-  constructor(@Attribute("maxlength") maxLength: string) {
+  constructor(@Attribute('maxlength') maxLength: string) {
     this._validator = Validators.maxLength(NumberWrapper.parseInt(maxLength, 10));
   }
 
@@ -108,6 +124,13 @@ export class MaxLengthValidator implements Validator {
 }
 
 
+export const PATTERN_VALIDATOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => PatternValidator),
+  multi: true
+};
+
+
 /**
  * A Directive that adds the `pattern` validator to any controls marked with the
  * `pattern` attribute, via the {@link NG_VALIDATORS} binding. Uses attribute value
@@ -119,9 +142,8 @@ export class MaxLengthValidator implements Validator {
  * ```
  * <input [ngControl]="fullName" pattern="[a-zA-Z ]*">
  * ```
+ * @experimental
  */
-const PATTERN_VALIDATOR = CONST_EXPR(
-    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => PatternValidator), multi: true}));
 @Directive({
   selector: '[pattern][ngControl],[pattern][ngFormControl],[pattern][ngModel]',
   providers: [PATTERN_VALIDATOR]
@@ -129,7 +151,7 @@ const PATTERN_VALIDATOR = CONST_EXPR(
 export class PatternValidator implements Validator {
   private _validator: ValidatorFn;
 
-  constructor(@Attribute("pattern") pattern: string) {
+  constructor(@Attribute('pattern') pattern: string) {
     this._validator = Validators.pattern(pattern);
   }
 

modules/@angular/common/src/forms-deprecated/form_builder.ts

@@ -1,8 +1,11 @@
-import {Injectable} from 'angular2/core';
-import {StringMapWrapper} from 'angular2/src/facade/collection';
-import {isPresent, isArray, CONST_EXPR, Type} from 'angular2/src/facade/lang';
+import {Injectable} from '@angular/core';
+
+import {StringMapWrapper} from '../facade/collection';
+import {isArray, isPresent} from '../facade/lang';
+
+import {AsyncValidatorFn, ValidatorFn} from './directives/validators';
 import * as modelModule from './model';
-import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
+
 
 
 /**
@@ -13,7 +16,7 @@ import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
  * ```typescript
  * @Component({
  *   selector: 'my-app',
- *   viewBindings: [FORM_BINDINGS]
+ *   viewProviders: [FORM_BINDINGS]
  *   template: `
  *     <form [ngFormModel]="loginForm">
  *       <p>Login <input ngControl="login"></p>
@@ -45,6 +48,8 @@ import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
  *   }
  * }
  * ```
+ *
+ * @experimental
  */
 @Injectable()
 export class FormBuilder {
@@ -54,21 +59,21 @@ export class FormBuilder {
    *
    * See the {@link ControlGroup} constructor for more details.
    */
-  group(controlsConfig: {[key: string]: any},
-        extra: {[key: string]: any} = null): modelModule.ControlGroup {
+  group(controlsConfig: {[key: string]: any}, extra: {[key: string]: any} = null):
+      modelModule.ControlGroup {
     var controls = this._reduceControls(controlsConfig);
     var optionals = <{[key: string]: boolean}>(
-        isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null);
-    var validator: ValidatorFn = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null;
+        isPresent(extra) ? StringMapWrapper.get(extra, 'optionals') : null);
+    var validator: ValidatorFn = isPresent(extra) ? StringMapWrapper.get(extra, 'validator') : null;
     var asyncValidator: AsyncValidatorFn =
-        isPresent(extra) ? StringMapWrapper.get(extra, "asyncValidator") : null;
+        isPresent(extra) ? StringMapWrapper.get(extra, 'asyncValidator') : null;
     return new modelModule.ControlGroup(controls, optionals, validator, asyncValidator);
   }
   /**
    * Construct a new {@link Control} with the given `value`,`validator`, and `asyncValidator`.
    */
-  control(value: Object, validator: ValidatorFn = null,
-          asyncValidator: AsyncValidatorFn = null): modelModule.Control {
+  control(value: Object, validator: ValidatorFn = null, asyncValidator: AsyncValidatorFn = null):
+      modelModule.Control {
     return new modelModule.Control(value, validator, asyncValidator);
   }
 
@@ -76,15 +81,16 @@ export class FormBuilder {
    * Construct an array of {@link Control}s from the given `controlsConfig` array of
    * configuration, with the given optional `validator` and `asyncValidator`.
    */
-  array(controlsConfig: any[], validator: ValidatorFn = null,
+  array(
+      controlsConfig: any[], validator: ValidatorFn = null,
       asyncValidator: AsyncValidatorFn = null): modelModule.ControlArray {
     var controls = controlsConfig.map(c => this._createControl(c));
     return new modelModule.ControlArray(controls, validator, asyncValidator);
   }
 
   /** @internal */
-  _reduceControls(controlsConfig: {[k: string]:
-                                       any}): {[key: string]: modelModule.AbstractControl} {
+  _reduceControls(controlsConfig: {[k: string]: any}):
+      {[key: string]: modelModule.AbstractControl} {
     var controls: {[key: string]: modelModule.AbstractControl} = {};
     StringMapWrapper.forEach(controlsConfig, (controlConfig: any, controlName: string) => {
       controls[controlName] = this._createControl(controlConfig);

modules/@angular/common/src/forms-deprecated/model.ts

@@ -1,24 +1,23 @@
-import {isPresent, isBlank, normalizeBool} from 'angular2/src/facade/lang';
-import {Observable, EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
-import {PromiseWrapper} from 'angular2/src/facade/promise';
-import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
-import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
+import {EventEmitter, Observable, ObservableWrapper} from '../facade/async';
+import {ListWrapper, StringMapWrapper} from '../facade/collection';
+import {isBlank, isPresent, isPromise, normalizeBool} from '../facade/lang';
+import {AsyncValidatorFn, ValidatorFn} from './directives/validators';
 
 /**
  * Indicates that a Control is valid, i.e. that no errors exist in the input value.
  */
-export const VALID = "VALID";
+export const VALID = 'VALID';
 
 /**
  * Indicates that a Control is invalid, i.e. that an error exists in the input value.
  */
-export const INVALID = "INVALID";
+export const INVALID = 'INVALID';
 
 /**
  * Indicates that a Control is pending, i.e. that async validation is occurring and
  * errors are not yet available for the input value.
  */
-export const PENDING = "PENDING";
+export const PENDING = 'PENDING';
 
 export function isControl(control: Object): boolean {
   return control instanceof AbstractControl;
@@ -28,12 +27,11 @@ function _find(control: AbstractControl, path: Array<string | number>| string) {
   if (isBlank(path)) return null;
 
   if (!(path instanceof Array)) {
-    path = (<string>path).split("/");
+    path = (<string>path).split('/');
   }
   if (path instanceof Array && ListWrapper.isEmpty(path)) return null;
 
-  return (<Array<string | number>>path)
-      .reduce((v, name) => {
+  return (<Array<string|number>>path).reduce((v, name) => {
     if (v instanceof ControlGroup) {
       return isPresent(v.controls[name]) ? v.controls[name] : null;
     } else if (v instanceof ControlArray) {
@@ -46,11 +44,11 @@ function _find(control: AbstractControl, path: Array<string | number>| string) {
 }
 
 function toObservable(r: any): Observable<any> {
-  return PromiseWrapper.isPromise(r) ? ObservableWrapper.fromPromise(r) : r;
+  return isPromise(r) ? ObservableWrapper.fromPromise(r) : r;
 }
 
 /**
- *
+ * @experimental
  */
 export abstract class AbstractControl {
   /** @internal */
@@ -114,8 +112,8 @@ export abstract class AbstractControl {
 
   setParent(parent: ControlGroup|ControlArray): void { this._parent = parent; }
 
-  updateValueAndValidity(
-      {onlySelf, emitEvent}: {onlySelf?: boolean, emitEvent?: boolean} = {}): void {
+  updateValueAndValidity({onlySelf, emitEvent}: {onlySelf?: boolean, emitEvent?: boolean} = {}):
+      void {
     onlySelf = normalizeBool(onlySelf);
     emitEvent = isPresent(emitEvent) ? emitEvent : true;
 
@@ -266,13 +264,15 @@ export abstract class AbstractControl {
  * validation function.
  *
  * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
+ *
+ * @experimental
  */
 export class Control extends AbstractControl {
   /** @internal */
   _onChange: Function;
 
-  constructor(value: any = null, validator: ValidatorFn = null,
-              asyncValidator: AsyncValidatorFn = null) {
+  constructor(
+      value: any = null, validator: ValidatorFn = null, asyncValidator: AsyncValidatorFn = null) {
     super(validator, asyncValidator);
     this._value = value;
     this.updateValueAndValidity({onlySelf: true, emitEvent: false});
@@ -331,13 +331,15 @@ export class Control extends AbstractControl {
  * controls, but is of variable length.
  *
  * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
+ *
+ * @experimental
  */
 export class ControlGroup extends AbstractControl {
   private _optionals: {[key: string]: boolean};
 
-  constructor(public controls: {[key: string]: AbstractControl},
-              optionals: {[key: string]: boolean} = null, validator: ValidatorFn = null,
-              asyncValidator: AsyncValidatorFn = null) {
+  constructor(
+      public controls: {[key: string]: AbstractControl}, optionals: {[key: string]: boolean} = null,
+      validator: ValidatorFn = null, asyncValidator: AsyncValidatorFn = null) {
     super(validator, asyncValidator);
     this._optionals = isPresent(optionals) ? optionals : {};
     this._initObservables();
@@ -346,17 +348,28 @@ export class ControlGroup extends AbstractControl {
   }
 
   /**
-   * Add a control to this group.
+   * Register a control with the group's list of controls.
    */
-  addControl(name: string, control: AbstractControl): void {
+  registerControl(name: string, control: AbstractControl): void {
     this.controls[name] = control;
     control.setParent(this);
   }
 
+  /**
+   * Add a control to this group.
+   */
+  addControl(name: string, control: AbstractControl): void {
+    this.registerControl(name, control);
+    this.updateValueAndValidity();
+  }
+
   /**
    * Remove a control from this group.
    */
-  removeControl(name: string): void { StringMapWrapper.delete(this.controls, name); }
+  removeControl(name: string): void {
+    StringMapWrapper.delete(this.controls, name);
+    this.updateValueAndValidity();
+  }
 
   /**
    * Mark the named control as non-optional.
@@ -448,9 +461,12 @@ export class ControlGroup extends AbstractControl {
  * as broken change detection.
  *
  * ### Example ([live demo](http://plnkr.co/edit/23DESOpbNnBpBHZt1BR4?p=preview))
+ *
+ * @experimental
  */
 export class ControlArray extends AbstractControl {
-  constructor(public controls: AbstractControl[], validator: ValidatorFn = null,
+  constructor(
+      public controls: AbstractControl[], validator: ValidatorFn = null,
       asyncValidator: AsyncValidatorFn = null) {
     super(validator, asyncValidator);
     this._initObservables();

modules/@angular/common/src/forms-deprecated/validators.ts

@@ -1,11 +1,10 @@
-import {isBlank, isPresent, CONST_EXPR, isString} 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';
-import {OpaqueToken} from 'angular2/core';
-
+import {OpaqueToken} from '@angular/core';
+import {ObservableWrapper} from '../facade/async';
+import {StringMapWrapper} from '../facade/collection';
+import {isBlank, isPresent, isPromise, isString} from '../facade/lang';
+import {PromiseWrapper} from '../facade/promise';
+import {AsyncValidatorFn, ValidatorFn} from './directives/validators';
 import * as modelModule from './model';
-import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
 
 /**
  * Providers for validators to be used for {@link Control}s in a form.
@@ -15,8 +14,9 @@ import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
  * ### Example
  *
  * {@example core/forms/ts/ng_validators/ng_validators.ts region='ng_validators'}
+ * @experimental
  */
-export const NG_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValidators"));
+export const NG_VALIDATORS: OpaqueToken = /*@ts2dart_const*/ new OpaqueToken('NgValidators');
 
 /**
  * Providers for asynchronous validators to be used for {@link Control}s
@@ -25,8 +25,11 @@ export const NG_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValidato
  * Provide this using `multi: true` to add validators.
  *
  * See {@link NG_VALIDATORS} for more details.
+ *
+ * @experimental
  */
-export const NG_ASYNC_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgAsyncValidators"));
+export const NG_ASYNC_VALIDATORS: OpaqueToken =
+    /*@ts2dart_const*/ new OpaqueToken('NgAsyncValidators');
 
 /**
  * Provides a set of validators used by form controls.
@@ -39,14 +42,16 @@ export const NG_ASYNC_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgAs
  * ```typescript
  * var loginControl = new Control("", Validators.required)
  * ```
+ *
+ * @experimental
  */
 export class Validators {
   /**
    * Validator that requires controls to have a non-empty value.
    */
   static required(control: modelModule.AbstractControl): {[key: string]: boolean} {
-    return isBlank(control.value) || (isString(control.value) && control.value == "") ?
-               {"required": true} :
+    return isBlank(control.value) || (isString(control.value) && control.value == '') ?
+        {'required': true} :
         null;
   }
 
@@ -58,7 +63,7 @@ export class Validators {
       if (isPresent(Validators.required(control))) return null;
       var v: string = control.value;
       return v.length < minLength ?
-                 {"minlength": {"requiredLength": minLength, "actualLength": v.length}} :
+          {'minlength': {'requiredLength': minLength, 'actualLength': v.length}} :
           null;
     };
   }
@@ -71,7 +76,7 @@ export class Validators {
       if (isPresent(Validators.required(control))) return null;
       var v: string = control.value;
       return v.length > maxLength ?
-                 {"maxlength": {"requiredLength": maxLength, "actualLength": v.length}} :
+          {'maxlength': {'requiredLength': maxLength, 'actualLength': v.length}} :
           null;
     };
   }
@@ -85,7 +90,7 @@ export class Validators {
       let regex = new RegExp(`^${pattern}$`);
       let v: string = control.value;
       return regex.test(v) ? null :
-                             {"pattern": {"requiredPattern": `^${pattern}$`, "actualValue": v}};
+                             {'pattern': {'requiredPattern': `^${pattern}$`, 'actualValue': v}};
     };
   }
 
@@ -120,17 +125,17 @@ export class Validators {
   }
 }
 
-function _convertToPromise(obj: any): any {
-  return PromiseWrapper.isPromise(obj) ? obj : ObservableWrapper.toPromise(obj);
+function _convertToPromise(obj: any): Promise<any> {
+  return isPromise(obj) ? obj : ObservableWrapper.toPromise(obj);
 }
 
-function _executeValidators(control: modelModule.AbstractControl,
-                            validators: ValidatorFn[]): any[] {
+function _executeValidators(
+    control: modelModule.AbstractControl, validators: ValidatorFn[]): any[] {
   return validators.map(v => v(control));
 }
 
-function _executeAsyncValidators(control: modelModule.AbstractControl,
-                                 validators: AsyncValidatorFn[]): any[] {
+function _executeAsyncValidators(
+    control: modelModule.AbstractControl, validators: AsyncValidatorFn[]): any[] {
   return validators.map(v => v(control));
 }
 

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

@@ -0,0 +1,5 @@
+export * from './location/platform_location';
+export * from './location/location_strategy';
+export * from './location/hash_location_strategy';
+export * from './location/path_location_strategy';
+export * from './location/location';

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

@@ -1,13 +1,12 @@
-import {Injectable, Inject, Optional} from 'angular2/core';
-import {
-  LocationStrategy,
-  joinWithSlash,
-  APP_BASE_HREF,
-  normalizeQueryParams
-} from './location_strategy';
-import {UrlChangeListener} from './platform_location';
-import {isPresent} from 'angular2/src/facade/lang';
-import {PlatformLocation} from './platform_location';
+import {Inject, Injectable, Optional} from '@angular/core';
+
+import {isPresent} from '../facade/lang';
+
+import {Location} from './location';
+import {APP_BASE_HREF, LocationStrategy} from './location_strategy';
+import {PlatformLocation, UrlChangeListener} from './platform_location';
+
+
 
 /**
  * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
@@ -21,15 +20,17 @@ import {PlatformLocation} from './platform_location';
  * ### Example
  *
  * ```
- * import {Component, provide} from 'angular2/core';
+ * import {Component, provide} from '@angular/core';
  * import {
- *   ROUTER_DIRECTIVES,
- *   ROUTER_PROVIDERS,
- *   RouteConfig,
  *   Location,
  *   LocationStrategy,
  *   HashLocationStrategy
- * } from 'angular2/router';
+ * } from '@angular/common';
+ * import {
+ *   ROUTER_DIRECTIVES,
+ *   ROUTER_PROVIDERS,
+ *   RouteConfig
+ * } from '@angular/router';
  *
  * @Component({directives: [ROUTER_DIRECTIVES]})
  * @RouteConfig([
@@ -43,14 +44,17 @@ import {PlatformLocation} from './platform_location';
  *
  * bootstrap(AppCmp, [
  *   ROUTER_PROVIDERS,
- *   provide(LocationStrategy, {useClass: HashLocationStrategy})
+ *   {provide: LocationStrategy, useClass: HashLocationStrategy}
  * ]);
  * ```
+ *
+ * @stable
  */
 @Injectable()
 export class HashLocationStrategy extends LocationStrategy {
   private _baseHref: string = '';
-  constructor(private _platformLocation: PlatformLocation,
+  constructor(
+      private _platformLocation: PlatformLocation,
       @Optional() @Inject(APP_BASE_HREF) _baseHref?: string) {
     super();
     if (isPresent(_baseHref)) {
@@ -78,12 +82,12 @@ export class HashLocationStrategy extends LocationStrategy {
   }
 
   prepareExternalUrl(internal: string): string {
-    var url = joinWithSlash(this._baseHref, internal);
+    var url = Location.joinWithSlash(this._baseHref, internal);
     return url.length > 0 ? ('#' + url) : url;
   }
 
   pushState(state: any, title: string, path: string, queryParams: string) {
-    var url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));
+    var url = this.prepareExternalUrl(path + Location.normalizeQueryParams(queryParams));
     if (url.length == 0) {
       url = this._platformLocation.pathname;
     }
@@ -91,7 +95,7 @@ export class HashLocationStrategy extends LocationStrategy {
   }
 
   replaceState(state: any, title: string, path: string, queryParams: string) {
-    var url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));
+    var url = this.prepareExternalUrl(path + Location.normalizeQueryParams(queryParams));
     if (url.length == 0) {
       url = this._platformLocation.pathname;
     }

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

@@ -1,6 +1,9 @@
+import {EventEmitter, Injectable} from '@angular/core';
+
+import {ObservableWrapper} from '../facade/async';
+
 import {LocationStrategy} from './location_strategy';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
-import {Injectable, Inject} from 'angular2/core';
+
 
 /**
  * `Location` is a service that applications can use to interact with a browser's URL.
@@ -21,13 +24,13 @@ import {Injectable, Inject} from 'angular2/core';
  * ### Example
  *
  * ```
- * import {Component} from 'angular2/core';
+ * import {Component} from '@angular/core';
+ * import {Location} from '@angular/common';
  * import {
  *   ROUTER_DIRECTIVES,
  *   ROUTER_PROVIDERS,
- *   RouteConfig,
- *   Location
- * } from 'angular2/router';
+ *   RouteConfig
+ * } from '@angular/router';
  *
  * @Component({directives: [ROUTER_DIRECTIVES]})
  * @RouteConfig([
@@ -41,6 +44,8 @@ import {Injectable, Inject} from 'angular2/core';
  *
  * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
  * ```
+ *
+ * @stable
  */
 @Injectable()
 export class Location {
@@ -49,10 +54,14 @@ export class Location {
   /** @internal */
   _baseHref: string;
 
-  constructor(public platformStrategy: LocationStrategy) {
-    var browserBaseHref = this.platformStrategy.getBaseHref();
-    this._baseHref = stripTrailingSlash(stripIndexHtml(browserBaseHref));
-    this.platformStrategy.onPopState((ev) => {
+  /** @internal */
+  _platformStrategy: LocationStrategy;
+
+  constructor(platformStrategy: LocationStrategy) {
+    this._platformStrategy = platformStrategy;
+    var browserBaseHref = this._platformStrategy.getBaseHref();
+    this._baseHref = Location.stripTrailingSlash(_stripIndexHtml(browserBaseHref));
+    this._platformStrategy.onPopState((ev) => {
       ObservableWrapper.callEmit(this._subject, {'url': this.path(), 'pop': true, 'type': ev.type});
     });
   }
@@ -60,14 +69,21 @@ export class Location {
   /**
    * Returns the normalized URL path.
    */
-  path(): string { return this.normalize(this.platformStrategy.path()); }
+  path(): string { return this.normalize(this._platformStrategy.path()); }
+
+  /**
+   * Normalizes the given path and compares to the current normalized path.
+   */
+  isCurrentPathEqualTo(path: string, query: string = ''): boolean {
+    return this.path() == this.normalize(path + Location.normalizeQueryParams(query));
+  }
 
   /**
    * Given a string representing a URL, returns the normalized URL path without leading or
    * trailing slashes
    */
   normalize(url: string): string {
-    return stripTrailingSlash(_stripBaseHref(this._baseHref, stripIndexHtml(url)));
+    return Location.stripTrailingSlash(_stripBaseHref(this._baseHref, _stripIndexHtml(url)));
   }
 
   /**
@@ -80,7 +96,7 @@ export class Location {
     if (url.length > 0 && !url.startsWith('/')) {
       url = '/' + url;
     }
-    return this.platformStrategy.prepareExternalUrl(url);
+    return this._platformStrategy.prepareExternalUrl(url);
   }
 
   // TODO: rename this method to pushState
@@ -89,7 +105,7 @@ export class Location {
    * new item onto the platform's history.
    */
   go(path: string, query: string = ''): void {
-    this.platformStrategy.pushState(null, '', path, query);
+    this._platformStrategy.pushState(null, '', path, query);
   }
 
   /**
@@ -97,26 +113,71 @@ export class Location {
    * the top item on the platform's history stack.
    */
   replaceState(path: string, query: string = ''): void {
-    this.platformStrategy.replaceState(null, '', path, query);
+    this._platformStrategy.replaceState(null, '', path, query);
   }
 
   /**
    * Navigates forward in the platform's history.
    */
-  forward(): void { this.platformStrategy.forward(); }
+  forward(): void { this._platformStrategy.forward(); }
 
   /**
    * Navigates back in the platform's history.
    */
-  back(): void { this.platformStrategy.back(); }
+  back(): void { this._platformStrategy.back(); }
 
   /**
    * Subscribe to the platform's `popState` events.
    */
-  subscribe(onNext: (value: any) => void, onThrow: (exception: any) => void = null,
+  subscribe(
+      onNext: (value: any) => void, onThrow: (exception: any) => void = null,
       onReturn: () => void = null): Object {
     return ObservableWrapper.subscribe(this._subject, onNext, onThrow, onReturn);
   }
+
+  /**
+   * Given a string of url parameters, prepend with '?' if needed, otherwise return parameters as
+   * is.
+   */
+  public static normalizeQueryParams(params: string): string {
+    return (params.length > 0 && params.substring(0, 1) != '?') ? ('?' + params) : params;
+  }
+
+  /**
+   * Given 2 parts of a url, join them with a slash if needed.
+   */
+  public static joinWithSlash(start: string, end: string): string {
+    if (start.length == 0) {
+      return end;
+    }
+    if (end.length == 0) {
+      return start;
+    }
+    var slashes = 0;
+    if (start.endsWith('/')) {
+      slashes++;
+    }
+    if (end.startsWith('/')) {
+      slashes++;
+    }
+    if (slashes == 2) {
+      return start + end.substring(1);
+    }
+    if (slashes == 1) {
+      return start + end;
+    }
+    return start + '/' + end;
+  }
+
+  /**
+   * If url has a trailing slash, remove it, otherwise return url as is.
+   */
+  public static stripTrailingSlash(url: string): string {
+    if (/\/$/g.test(url)) {
+      url = url.substring(0, url.length - 1);
+    }
+    return url;
+  }
 }
 
 function _stripBaseHref(baseHref: string, url: string): string {
@@ -126,17 +187,10 @@ function _stripBaseHref(baseHref: string, url: string): string {
   return url;
 }
 
-function stripIndexHtml(url: string): string {
+function _stripIndexHtml(url: string): string {
   if (/\/index.html$/g.test(url)) {
     // '/index.html'.length == 11
     return url.substring(0, url.length - 11);
   }
   return url;
 }
-
-function stripTrailingSlash(url: string): string {
-  if (/\/$/g.test(url)) {
-    url = url.substring(0, url.length - 1);
-  }
-  return url;
-}

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

@@ -1,5 +1,4 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {OpaqueToken} from 'angular2/core';
+import {OpaqueToken} from '@angular/core';
 import {UrlChangeListener} from './platform_location';
 
 /**
@@ -17,6 +16,8 @@ import {UrlChangeListener} from './platform_location';
  * `http://example.com/foo` as an equivalent URL.
  *
  * See these two classes for more.
+ *
+ * @stable
  */
 export abstract class LocationStrategy {
   abstract path(): string;
@@ -41,8 +42,9 @@ export abstract class LocationStrategy {
  * ### Example
  *
  * ```
- * import {Component} from 'angular2/core';
- * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ * import {Component} from '@angular/core';
+ * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from '@angular/router';
+ * import {APP_BASE_HREF} from '@angular/common';
  *
  * @Component({directives: [ROUTER_DIRECTIVES]})
  * @RouteConfig([
@@ -54,35 +56,9 @@ export abstract class LocationStrategy {
  *
  * bootstrap(AppCmp, [
  *   ROUTER_PROVIDERS,
- *   provide(APP_BASE_HREF, {useValue: '/my/app'})
+ *   {provide: APP_BASE_HREF, useValue: '/my/app'}
  * ]);
  * ```
+ * @stable
  */
-export const APP_BASE_HREF: OpaqueToken = CONST_EXPR(new OpaqueToken('appBaseHref'));
-
-export function normalizeQueryParams(params: string): string {
-  return (params.length > 0 && params.substring(0, 1) != '?') ? ('?' + params) : params;
-}
-
-export function joinWithSlash(start: string, end: string): string {
-  if (start.length == 0) {
-    return end;
-  }
-  if (end.length == 0) {
-    return start;
-  }
-  var slashes = 0;
-  if (start.endsWith('/')) {
-    slashes++;
-  }
-  if (end.startsWith('/')) {
-    slashes++;
-  }
-  if (slashes == 2) {
-    return start + end.substring(1);
-  }
-  if (slashes == 1) {
-    return start + end;
-  }
-  return start + '/' + end;
-}
+export const APP_BASE_HREF: OpaqueToken = /*@ts2dart_const*/ new OpaqueToken('appBaseHref');

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

@@ -1,14 +1,13 @@
-import {Injectable, Inject, Optional} from 'angular2/core';
-import {isBlank} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
-import {
-  LocationStrategy,
-  APP_BASE_HREF,
-  normalizeQueryParams,
-  joinWithSlash
-} from './location_strategy';
+import {Inject, Injectable, Optional} from '@angular/core';
+
+import {BaseException} from '../facade/exceptions';
+import {isBlank} from '../facade/lang';
+
+import {Location} from './location';
+import {APP_BASE_HREF, LocationStrategy} from './location_strategy';
 import {PlatformLocation, UrlChangeListener} from './platform_location';
 
+
 /**
  * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
  * {@link Location} service to represent its state in the
@@ -29,14 +28,17 @@ import {PlatformLocation, UrlChangeListener} from './platform_location';
  * ### Example
  *
  * ```
- * import {Component, provide} from 'angular2/core';
+ * import {Component} from '@angular/core';
+ * import {bootstrap} from '@angular/platform-browser/browser';
  * import {
+ *   Location,
  *   APP_BASE_HREF
+ * } from '@angular/common';
+ * import {
  *   ROUTER_DIRECTIVES,
  *   ROUTER_PROVIDERS,
- *   RouteConfig,
- *   Location
- * } from 'angular2/router';
+ *   RouteConfig
+ * } from '@angular/router';
  *
  * @Component({directives: [ROUTER_DIRECTIVES]})
  * @RouteConfig([
@@ -50,15 +52,18 @@ import {PlatformLocation, UrlChangeListener} from './platform_location';
  *
  * bootstrap(AppCmp, [
  *   ROUTER_PROVIDERS, // includes binding to PathLocationStrategy
- *   provide(APP_BASE_HREF, {useValue: '/my/app'})
+ *   {provide: APP_BASE_HREF, useValue: '/my/app'}
  * ]);
  * ```
+ *
+ * @stable
  */
 @Injectable()
 export class PathLocationStrategy extends LocationStrategy {
   private _baseHref: string;
 
-  constructor(private _platformLocation: PlatformLocation,
+  constructor(
+      private _platformLocation: PlatformLocation,
       @Optional() @Inject(APP_BASE_HREF) href?: string) {
     super();
 
@@ -81,19 +86,22 @@ export class PathLocationStrategy extends LocationStrategy {
 
   getBaseHref(): string { return this._baseHref; }
 
-  prepareExternalUrl(internal: string): string { return joinWithSlash(this._baseHref, internal); }
+  prepareExternalUrl(internal: string): string {
+    return Location.joinWithSlash(this._baseHref, internal);
+  }
 
   path(): string {
-    return this._platformLocation.pathname + normalizeQueryParams(this._platformLocation.search);
+    return this._platformLocation.pathname +
+        Location.normalizeQueryParams(this._platformLocation.search);
   }
 
   pushState(state: any, title: string, url: string, queryParams: string) {
-    var externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    var externalUrl = this.prepareExternalUrl(url + Location.normalizeQueryParams(queryParams));
     this._platformLocation.pushState(state, title, externalUrl);
   }
 
   replaceState(state: any, title: string, url: string, queryParams: string) {
-    var externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    var externalUrl = this.prepareExternalUrl(url + Location.normalizeQueryParams(queryParams));
     this._platformLocation.replaceState(state, title, externalUrl);
   }
 

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

@@ -21,15 +21,17 @@
  * {@link Location} / {@link LocationStrategy} and DOM apis flow through the `PlatformLocation`
  * class
  * they are all platform independent.
+ *
+ * @stable
  */
 export abstract class PlatformLocation {
   abstract getBaseHrefFromDOM(): string;
   abstract onPopState(fn: UrlChangeListener): void;
   abstract onHashChange(fn: UrlChangeListener): void;
 
-  /* abstract */ get pathname(): string { return null; }
-  /* abstract */ get search(): string { return null; }
-  /* abstract */ get hash(): string { return null; }
+  get pathname(): string { return null; }
+  get search(): string { return null; }
+  get hash(): string { return null; }
 
   abstract replaceState(state: any, title: string, url: string): void;
 
@@ -42,6 +44,8 @@ export abstract class PlatformLocation {
 
 /**
  * A serializable version of the event from onPopState or onHashChange
+ *
+ * @stable
  */
 export interface UrlChangeEvent { type: string; }
 

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

@@ -5,13 +5,13 @@
  */
 
 export {AsyncPipe} from './pipes/async_pipe';
+export {COMMON_PIPES} from './pipes/common_pipes';
 export {DatePipe} from './pipes/date_pipe';
-export {JsonPipe} from './pipes/json_pipe';
-export {SlicePipe} from './pipes/slice_pipe';
-export {LowerCasePipe} from './pipes/lowercase_pipe';
-export {NumberPipe, DecimalPipe, PercentPipe, CurrencyPipe} from './pipes/number_pipe';
-export {UpperCasePipe} from './pipes/uppercase_pipe';
-export {ReplacePipe} from './pipes/replace_pipe';
 export {I18nPluralPipe} from './pipes/i18n_plural_pipe';
 export {I18nSelectPipe} from './pipes/i18n_select_pipe';
-export {COMMON_PIPES} from './pipes/common_pipes';
+export {JsonPipe} from './pipes/json_pipe';
+export {LowerCasePipe} from './pipes/lowercase_pipe';
+export {CurrencyPipe, DecimalPipe, PercentPipe} from './pipes/number_pipe';
+export {ReplacePipe} from './pipes/replace_pipe';
+export {SlicePipe} from './pipes/slice_pipe';
+export {UpperCasePipe} from './pipes/uppercase_pipe';

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

@@ -1,17 +1,15 @@
-import {isBlank, isPresent, isPromise, CONST} from 'angular2/src/facade/lang';
-import {ObservableWrapper, Observable, EventEmitter} from 'angular2/src/facade/async';
-import {
-  Pipe,
-  Injectable,
-  ChangeDetectorRef,
-  OnDestroy,
-  PipeTransform,
-  WrappedValue
-} from 'angular2/core';
-
+import {ChangeDetectorRef, OnDestroy, Pipe, WrappedValue} from '@angular/core';
+import {EventEmitter, Observable, ObservableWrapper} from '../facade/async';
+import {isBlank, isPresent, isPromise} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-class ObservableStrategy {
+interface SubscriptionStrategy {
+  createSubscription(async: any, updateLatestValue: any): any;
+  dispose(subscription: any): void;
+  onDestroy(subscription: any): void;
+}
+
+class ObservableStrategy implements SubscriptionStrategy {
   createSubscription(async: any, updateLatestValue: any): any {
     return ObservableWrapper.subscribe(async, updateLatestValue, e => { throw e; });
   }
@@ -21,9 +19,9 @@ class ObservableStrategy {
   onDestroy(subscription: any): void { ObservableWrapper.dispose(subscription); }
 }
 
-class PromiseStrategy {
+class PromiseStrategy implements SubscriptionStrategy {
   createSubscription(async: Promise<any>, updateLatestValue: (v: any) => any): any {
-    return async.then(updateLatestValue);
+    return async.then(updateLatestValue, e => { throw e; });
   }
 
   dispose(subscription: any): void {}
@@ -36,26 +34,34 @@ var _observableStrategy = new ObservableStrategy();
 var __unused: Promise<any>;  // avoid unused import when Promise union types are erased
 
 /**
- * The `async` pipe subscribes to an Observable or Promise and returns the latest value it has
+ * The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has
  * emitted.
  * When a new value is emitted, the `async` pipe marks the component to be checked for changes.
+ * When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid
+ * potential memory leaks.
  *
- * ### Example
+ * ## Usage
+ *
+ *     object | async
+ *
+ * where `object` is of type `Observable` or of type `Promise`.
+ *
+ * ## Examples
  *
  * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
  * promise.
  *
- * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipe'}
+ * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipePromise'}
  *
  * It's also possible to use `async` with Observables. The example below binds the `time` Observable
  * to the view. Every 500ms, the `time` Observable updates the view with the current time.
  *
- * ```typescript
- * ```
+ * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipeObservable'}
+ *
+ * @stable
  */
 @Pipe({name: 'async', pure: false})
-@Injectable()
-export class AsyncPipe implements PipeTransform, OnDestroy {
+export class AsyncPipe implements OnDestroy {
   /** @internal */
   _latestValue: Object = null;
   /** @internal */
@@ -65,9 +71,10 @@ export class AsyncPipe implements PipeTransform, OnDestroy {
   _subscription: Object = null;
   /** @internal */
   _obj: Observable<any>|Promise<any>|EventEmitter<any> = null;
-  private _strategy: any = null;
   /** @internal */
-  public _ref: ChangeDetectorRef;
+  _ref: ChangeDetectorRef;
+  private _strategy: SubscriptionStrategy = null;
+
   constructor(_ref: ChangeDetectorRef) { this._ref = _ref; }
 
   ngOnDestroy(): void {
@@ -76,7 +83,7 @@ export class AsyncPipe implements PipeTransform, OnDestroy {
     }
   }
 
-  transform(obj: Observable<any>| Promise<any>| EventEmitter<any>, args?: any[]): any {
+  transform(obj: Observable<any>|Promise<any>|EventEmitter<any>): any {
     if (isBlank(this._obj)) {
       if (isPresent(obj)) {
         this._subscribe(obj);

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

@@ -4,16 +4,16 @@
  * This module provides a set of common Pipes.
  */
 import {AsyncPipe} from './async_pipe';
-import {UpperCasePipe} from './uppercase_pipe';
-import {LowerCasePipe} from './lowercase_pipe';
-import {JsonPipe} from './json_pipe';
-import {SlicePipe} from './slice_pipe';
 import {DatePipe} from './date_pipe';
-import {DecimalPipe, PercentPipe, CurrencyPipe} from './number_pipe';
-import {ReplacePipe} from './replace_pipe';
 import {I18nPluralPipe} from './i18n_plural_pipe';
 import {I18nSelectPipe} from './i18n_select_pipe';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+import {JsonPipe} from './json_pipe';
+import {LowerCasePipe} from './lowercase_pipe';
+import {CurrencyPipe, DecimalPipe, PercentPipe} from './number_pipe';
+import {ReplacePipe} from './replace_pipe';
+import {SlicePipe} from './slice_pipe';
+import {UpperCasePipe} from './uppercase_pipe';
+
 
 /**
  * A collection of Angular core pipes that are likely to be used in each and every
@@ -21,8 +21,10 @@ import {CONST_EXPR} from 'angular2/src/facade/lang';
  *
  * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`
  * property of the `@Component` decorator.
+ *
+ * @experimental Contains i18n pipes which are experimental
  */
-export const COMMON_PIPES = CONST_EXPR([
+export const COMMON_PIPES = /*@ts2dart_const*/[
   AsyncPipe,
   UpperCasePipe,
   LowerCasePipe,
@@ -34,5 +36,5 @@ export const COMMON_PIPES = CONST_EXPR([
   DatePipe,
   ReplacePipe,
   I18nPluralPipe,
-  I18nSelectPipe
-]);
+  I18nSelectPipe,
+];

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

@@ -1,20 +1,9 @@
-import {
-  isDate,
-  isNumber,
-  isPresent,
-  Date,
-  DateWrapper,
-  CONST,
-  isBlank,
-  FunctionWrapper
-} from 'angular2/src/facade/lang';
-import {DateFormatter} from 'angular2/src/facade/intl';
-import {PipeTransform, WrappedValue, Pipe, Injectable} from 'angular2/core';
-import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
-
+import {Pipe, PipeTransform} from '@angular/core';
+import {StringMapWrapper} from '../facade/collection';
+import {DateFormatter} from '../facade/intl';
+import {DateWrapper, NumberWrapper, isBlank, isDate, isString} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-
 // TODO: move to a global configurable location along with other i18n components.
 var defaultLocale: string = 'en-US';
 
@@ -33,8 +22,9 @@ var defaultLocale: string = 'en-US';
  *
  *     expression | date[:format]
  *
- * where `expression` is a date object or a number (milliseconds since UTC epoch) and
- * `format` indicates which date/time components to include:
+ * where `expression` is a date object or a number (milliseconds since UTC epoch) or an ISO string
+ * (https://www.w3.org/TR/NOTE-datetime) and `format` indicates which date/time components to
+ * include:
  *
  *  | Component | Symbol | Short Form   | Long Form         | Numeric   | 2-digit   |
  *  |-----------|:------:|--------------|-------------------|-----------|-----------|
@@ -55,7 +45,7 @@ var defaultLocale: string = 'en-US';
  * punctuations, ...) and details of the formatting will be dependent on the locale.
  * On the other hand in Dart version, you can also include quoted text as well as some extra
  * date/time components such as quarter. For more information see:
- * https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/intl/intl.DateFormat.
+ * https://www.dartdocs.org/documentation/intl/0.13.0/intl/DateFormat-class.html
  *
  * `format` can also be one of the following predefined formats:
  *
@@ -83,10 +73,10 @@ var defaultLocale: string = 'en-US';
  * ```
  *
  * {@example core/pipes/ts/date_pipe/date_pipe_example.ts region='DatePipe'}
+ *
+ * @experimental
  */
-@CONST()
 @Pipe({name: 'date', pure: true})
-@Injectable()
 export class DatePipe implements PipeTransform {
   /** @internal */
   static _ALIASES: {[key: string]: String} = {
@@ -101,16 +91,17 @@ export class DatePipe implements PipeTransform {
   };
 
 
-  transform(value: any, args: any[]): string {
+  transform(value: any, pattern: string = 'mediumDate'): string {
     if (isBlank(value)) return null;
 
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentException(DatePipe, value);
     }
 
-    var pattern: string = isPresent(args) && args.length > 0 ? args[0] : 'mediumDate';
-    if (isNumber(value)) {
-      value = DateWrapper.fromMillis(value);
+    if (NumberWrapper.isNumeric(value)) {
+      value = DateWrapper.fromMillis(NumberWrapper.parseInt(value, 10));
+    } else if (isString(value)) {
+      value = DateWrapper.fromISOString(value);
     }
     if (StringMapWrapper.contains(DatePipe._ALIASES, pattern)) {
       pattern = <string>StringMapWrapper.get(DatePipe._ALIASES, pattern);
@@ -118,5 +109,13 @@ export class DatePipe implements PipeTransform {
     return DateFormatter.format(value, defaultLocale, pattern);
   }
 
-  supports(obj: any): boolean { return isDate(obj) || isNumber(obj); }
+  private supports(obj: any): boolean {
+    if (isDate(obj) || NumberWrapper.isNumeric(obj)) {
+      return true;
+    }
+    if (isString(obj) && isDate(DateWrapper.fromISOString(obj))) {
+      return true;
+    }
+    return false;
+  }
 }

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

@@ -1,14 +1,8 @@
-import {
-  CONST,
-  isStringMap,
-  StringWrapper,
-  isPresent,
-  RegExpWrapper
-} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {StringWrapper, isPresent, isStringMap} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-var interpolationExp: RegExp = RegExpWrapper.create('#');
+const _INTERPOLATION_REGEXP: RegExp = /#/g;
 
 /**
  *
@@ -40,15 +34,13 @@ var interpolationExp: RegExp = RegExpWrapper.create('#');
  *  }
  *  ```
  *
+ * @experimental
  */
-@CONST()
 @Pipe({name: 'i18nPlural', pure: true})
-@Injectable()
 export class I18nPluralPipe implements PipeTransform {
-  transform(value: number, args: any[] = null): string {
+  transform(value: number, pluralMap: {[count: string]: string}): string {
     var key: string;
     var valueStr: string;
-    var pluralMap: {[count: string]: string} = <{[count: string]: string}>(args[0]);
 
     if (!isStringMap(pluralMap)) {
       throw new InvalidPipeArgumentException(I18nPluralPipe, pluralMap);
@@ -57,6 +49,6 @@ export class I18nPluralPipe implements PipeTransform {
     key = value === 0 || value === 1 ? `=${value}` : 'other';
     valueStr = isPresent(value) ? value.toString() : '';
 
-    return StringWrapper.replaceAll(pluralMap[key], interpolationExp, valueStr);
+    return StringWrapper.replaceAll(pluralMap[key], _INTERPOLATION_REGEXP, valueStr);
   }
 }

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

@@ -1,8 +1,9 @@
-import {CONST, isStringMap} from 'angular2/src/facade/lang';
-import {StringMapWrapper} from 'angular2/src/facade/collection';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {StringMapWrapper} from '../facade/collection';
+import {isStringMap} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
+
 /**
  *
  *  Generic selector that displays the string that matches the current value.
@@ -31,13 +32,12 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  *    ...
  *  }
  *  ```
+ *
+ *  @experimental
  */
-@CONST()
 @Pipe({name: 'i18nSelect', pure: true})
-@Injectable()
 export class I18nSelectPipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
-    var mapping: {[key: string]: string} = <{[count: string]: string}>(args[0]);
+  transform(value: string, mapping: {[key: string]: string}): string {
     if (!isStringMap(mapping)) {
       throw new InvalidPipeArgumentException(I18nSelectPipe, mapping);
     }

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

@@ -1,5 +1,5 @@
-import {CONST, Type, stringify} from 'angular2/src/facade/lang';
-import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
+import {BaseException} from '../facade/exceptions';
+import {Type, stringify} from '../facade/lang';
 
 export class InvalidPipeArgumentException extends BaseException {
   constructor(type: Type, value: Object) {

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

@@ -1,15 +1,18 @@
-import {isBlank, isPresent, Json, CONST} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+
+import {Json} from '../facade/lang';
+
+
 
 /**
  * Transforms any input value using `JSON.stringify`. Useful for debugging.
  *
  * ### Example
  * {@example core/pipes/ts/json_pipe/json_pipe_example.ts region='JsonPipe'}
+ *
+ * @stable
  */
-@CONST()
 @Pipe({name: 'json', pure: false})
-@Injectable()
 export class JsonPipe implements PipeTransform {
-  transform(value: any, args: any[] = null): string { return Json.stringify(value); }
+  transform(value: any): string { return Json.stringify(value); }
 }

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

@@ -1,19 +1,20 @@
-import {isString, CONST, isBlank} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank, isString} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
+
 /**
  * Transforms text to lowercase.
  *
  * ### Example
  *
  * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
+ *
+ * @experimental
  */
-@CONST()
 @Pipe({name: 'lowercase'})
-@Injectable()
 export class LowerCasePipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
+  transform(value: string): string {
     if (isBlank(value)) return value;
     if (!isString(value)) {
       throw new InvalidPipeArgumentException(LowerCasePipe, value);

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

@@ -0,0 +1,139 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {BaseException} from '../facade/exceptions';
+import {NumberFormatStyle, NumberFormatter} from '../facade/intl';
+import {NumberWrapper, RegExpWrapper, Type, isBlank, isNumber, isPresent} from '../facade/lang';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+var defaultLocale: string = 'en-US';
+const _NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(\-(\d+))?)?$/g;
+
+/**
+ * Internal function to format numbers used by Decimal, Percent and Date pipes.
+ */
+function formatNumber(
+    pipe: Type, value: number, style: NumberFormatStyle, digits: string, currency: string = null,
+    currencyAsSymbol: boolean = false): string {
+  if (isBlank(value)) return null;
+  if (!isNumber(value)) {
+    throw new InvalidPipeArgumentException(pipe, value);
+  }
+  var minInt = 1, minFraction = 0, maxFraction = 3;
+  if (isPresent(digits)) {
+    var parts = RegExpWrapper.firstMatch(_NUMBER_FORMAT_REGEXP, digits);
+    if (isBlank(parts)) {
+      throw new BaseException(`${digits} is not a valid digit info for number pipes`);
+    }
+    if (isPresent(parts[1])) {  // min integer digits
+      minInt = NumberWrapper.parseIntAutoRadix(parts[1]);
+    }
+    if (isPresent(parts[3])) {  // min fraction digits
+      minFraction = NumberWrapper.parseIntAutoRadix(parts[3]);
+    }
+    if (isPresent(parts[5])) {  // max fraction digits
+      maxFraction = NumberWrapper.parseIntAutoRadix(parts[5]);
+    }
+  }
+  return NumberFormatter.format(value, defaultLocale, style, {
+    minimumIntegerDigits: minInt,
+    minimumFractionDigits: minFraction,
+    maximumFractionDigits: maxFraction,
+    currency: currency,
+    currencyAsSymbol: currencyAsSymbol
+  });
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers. For other browsers please use an
+ * polyfill, for example: [https://github.com/andyearnshaw/Intl.js/].
+ *
+ * Formats a number as local text. i.e. group sizing and separator and other locale-specific
+ * configurations are based on the active locale.
+ *
+ * ### Usage
+ *
+ *     expression | number[:digitInfo]
+ *
+ * where `expression` is a number and `digitInfo` has the following format:
+ *
+ *     {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}
+ *
+ * - minIntegerDigits is the minimum number of integer digits to use. Defaults to 1.
+ * - minFractionDigits is the minimum number of digits after fraction. Defaults to 0.
+ * - maxFractionDigits is the maximum number of digits after fraction. Defaults to 3.
+ *
+ * For more information on the acceptable range for each of these numbers and other
+ * details see your native internationalization library.
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='NumberPipe'}
+ *
+ * @experimental
+ */
+@Pipe({name: 'number'})
+export class DecimalPipe implements PipeTransform {
+  transform(value: any, digits: string = null): string {
+    return formatNumber(DecimalPipe, value, NumberFormatStyle.Decimal, digits);
+  }
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers. For other browsers please use an
+ * polyfill, for example: [https://github.com/andyearnshaw/Intl.js/].
+ *
+ * Formats a number as local percent.
+ *
+ * ### Usage
+ *
+ *     expression | percent[:digitInfo]
+ *
+ * For more information about `digitInfo` see {@link DecimalPipe}
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='PercentPipe'}
+ *
+ * @experimental
+ */
+@Pipe({name: 'percent'})
+export class PercentPipe implements PipeTransform {
+  transform(value: any, digits: string = null): string {
+    return formatNumber(PercentPipe, value, NumberFormatStyle.Percent, digits);
+  }
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers. For other browsers please use an
+ * polyfill, for example: [https://github.com/andyearnshaw/Intl.js/].
+ *
+ *
+ * Formats a number as local currency.
+ *
+ * ### Usage
+ *
+ *     expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]
+ *
+ * where `currencyCode` is the ISO 4217 currency code, such as "USD" for the US dollar and
+ * "EUR" for the euro. `symbolDisplay` is a boolean indicating whether to use the currency
+ * symbol (e.g. $) or the currency code (e.g. USD) in the output. The default for this value
+ * is `false`.
+ * For more information about `digitInfo` see {@link DecimalPipe}
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='CurrencyPipe'}
+ *
+ * @experimental
+ */
+@Pipe({name: 'currency'})
+export class CurrencyPipe implements PipeTransform {
+  transform(
+      value: any, currencyCode: string = 'USD', symbolDisplay: boolean = false,
+      digits: string = null): string {
+    return formatNumber(
+        CurrencyPipe, value, NumberFormatStyle.Currency, digits, currencyCode, symbolDisplay);
+  }
+}

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

@@ -1,13 +1,5 @@
-import {
-  isBlank,
-  isString,
-  isNumber,
-  isFunction,
-  RegExpWrapper,
-  StringWrapper
-} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {RegExpWrapper, StringWrapper, isBlank, isFunction, isNumber, isString} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -34,16 +26,15 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  * --Note--: The 'pattern' parameter will be converted to a RegExp instance. Make sure to escape the
  * string properly if you are matching for regular expression special characters like parenthesis,
  * brackets etc.
+ *
+ * @deprecated The current pipe has limited functionality. The pipe api is not meant to be able
+ * express complex yet generic value transformations. We recommend that these transformations happen
+ * in the component logic instead.
  */
 
 @Pipe({name: 'replace'})
-@Injectable()
 export class ReplacePipe implements PipeTransform {
-  transform(value: any, args: any[]): any {
-    if (isBlank(args) || args.length !== 2) {
-      throw new BaseException('ReplacePipe requires two arguments');
-    }
-
+  transform(value: any, pattern: string|RegExp, replacement: Function|string): any {
     if (isBlank(value)) {
       return value;
     }
@@ -53,9 +44,6 @@ export class ReplacePipe implements PipeTransform {
     }
 
     var input = value.toString();
-    var pattern = args[0];
-    var replacement = args[1];
-
 
     if (!this._supportedPattern(pattern)) {
       throw new InvalidPipeArgumentException(ReplacePipe, pattern);
@@ -63,20 +51,20 @@ export class ReplacePipe implements PipeTransform {
     if (!this._supportedReplacement(replacement)) {
       throw new InvalidPipeArgumentException(ReplacePipe, replacement);
     }
-    // template fails with literal RegExp e.g /pattern/igm
-    // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
 
     if (isFunction(replacement)) {
-      var rgxPattern = isString(pattern) ? RegExpWrapper.create(pattern) : pattern;
+      const rgxPattern = isString(pattern) ? RegExpWrapper.create(pattern) : pattern;
 
-      return StringWrapper.replaceAllMapped(input, rgxPattern, replacement);
+      return StringWrapper.replaceAllMapped(
+          input, rgxPattern, <(m: string[]) => string>replacement);
     }
+
     if (pattern instanceof RegExp) {
       // use the replaceAll variant
-      return StringWrapper.replaceAll(input, pattern, replacement);
+      return StringWrapper.replaceAll(input, pattern, <string>replacement);
     }
 
-    return StringWrapper.replace(input, pattern, replacement);
+    return StringWrapper.replace(input, <string>pattern, <string>replacement);
   }
 
   private _supportedInput(input: any): boolean { return isString(input) || isNumber(input); }

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

@@ -1,7 +1,6 @@
-import {isBlank, isString, isArray, StringWrapper, CONST} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
-import {ListWrapper} from 'angular2/src/facade/collection';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {ListWrapper} from '../facade/collection';
+import {StringWrapper, isArray, isBlank, isString} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -40,6 +39,8 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  * When operating on a [List], the returned list is always a copy even when all
  * the elements are being returned.
  *
+ * When operating on a blank value, returns it.
+ *
  * ## List Example
  *
  * This `ngFor` example:
@@ -54,21 +55,17 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  * ## String Examples
  *
  * {@example core/pipes/ts/slice_pipe/slice_pipe_example.ts region='SlicePipe_string'}
+ *
+ * @stable
  */
 
 @Pipe({name: 'slice', pure: false})
-@Injectable()
 export class SlicePipe implements PipeTransform {
-  transform(value: any, args: any[] = null): any {
-    if (isBlank(args) || args.length == 0) {
-      throw new BaseException('Slice pipe requires one argument');
-    }
+  transform(value: any, start: number, end: number = null): any {
+    if (isBlank(value)) return value;
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentException(SlicePipe, value);
     }
-    if (isBlank(value)) return value;
-    var start: number = args[0];
-    var end: number = args.length > 1 ? args[1] : null;
     if (isString(value)) {
       return StringWrapper.slice(value, start, end);
     }

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

@@ -1,5 +1,5 @@
-import {isString, CONST, isBlank} from 'angular2/src/facade/lang';
-import {PipeTransform, WrappedValue, Injectable, Pipe} from 'angular2/core';
+import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank, isString} from '../facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -8,12 +8,12 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  * ### Example
  *
  * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
+ *
+ * @experimental
  */
-@CONST()
 @Pipe({name: 'uppercase'})
-@Injectable()
 export class UpperCasePipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
+  transform(value: string): string {
     if (isBlank(value)) return value;
     if (!isString(value)) {
       throw new InvalidPipeArgumentException(UpperCasePipe, value);

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

@@ -0,0 +1,590 @@
+import {beforeEach, beforeEachProviders, ddescribe, xdescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {ComponentFixture, TestComponentBuilder} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {ListWrapper, StringMapWrapper, SetWrapper} from '../../src/facade/collection';
+import {Component, provide} from '@angular/core';
+import {NgFor, NgClass} from '@angular/common';
+
+function detectChangesAndCheck(fixture: ComponentFixture<any>, classes: string) {
+  fixture.detectChanges();
+  expect(fixture.debugElement.children[0].nativeElement.className).toEqual(classes);
+}
+
+export function main() {
+  describe('binding to CSS class list', () => {
+
+    it('should clean up when the directive is destroyed',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div *ngFor="let item of items" [ngClass]="item"></div>';
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [['0']];
+                   fixture.detectChanges();
+                   fixture.debugElement.componentInstance.items = [['1']];
+
+                   detectChangesAndCheck(fixture, '1');
+
+                   async.done();
+                 });
+           }));
+
+
+    describe('expressions evaluating to objects', () => {
+
+      it('should add classes specified in an object literal',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="{foo: true, bar: false}"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+                     async.done();
+                   });
+             }));
+
+
+      it('should add classes specified in an object literal without change in class names',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="{'foo-bar': true, 'fooBar': true}"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo-bar fooBar');
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes based on changes in object literal values',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="{foo: condition, bar: !condition}"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.condition = false;
+                     detectChangesAndCheck(fixture, 'bar');
+
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes based on changes to the expression object',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'baz', true);
+                     detectChangesAndCheck(fixture, 'foo bar baz');
+
+                     StringMapWrapper.delete(fixture.debugElement.componentInstance.objExpr, 'bar');
+                     detectChangesAndCheck(fixture, 'foo baz');
+
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes based on reference changes to the expression object',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.objExpr = {foo: true, bar: true};
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+                     fixture.debugElement.componentInstance.objExpr = {baz: true};
+                     detectChangesAndCheck(fixture, 'baz');
+
+                     async.done();
+                   });
+             }));
+
+      it('should remove active classes when expression evaluates to null',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.objExpr = null;
+                     detectChangesAndCheck(fixture, '');
+
+                     fixture.debugElement.componentInstance.objExpr = {'foo': false, 'bar': true};
+                     detectChangesAndCheck(fixture, 'bar');
+
+                     async.done();
+                   });
+             }));
+
+
+      it('should allow multiple classes per expression',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+
+                     fixture.debugElement.componentInstance.objExpr = {
+                       'bar baz': true,
+                       'bar1 baz1': true
+                     };
+                     detectChangesAndCheck(fixture, 'bar baz bar1 baz1');
+
+                     fixture.debugElement.componentInstance.objExpr = {
+                       'bar baz': false,
+                       'bar1 baz1': true
+                     };
+                     detectChangesAndCheck(fixture, 'bar1 baz1');
+
+
+                     async.done();
+                   });
+             }));
+
+      it('should split by one or more spaces between classes',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+
+                     fixture.debugElement.componentInstance.objExpr = {'foo bar     baz': true};
+                     detectChangesAndCheck(fixture, 'foo bar baz');
+
+                     async.done();
+                   });
+             }));
+
+    });
+
+    describe('expressions evaluating to lists', () => {
+
+      it('should add classes specified in a list literal',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="['foo', 'bar', 'foo-bar', 'fooBar']"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes based on changes to the expression',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     var arrExpr: string[] = fixture.debugElement.componentInstance.arrExpr;
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     arrExpr.push('bar');
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+                     arrExpr[1] = 'baz';
+                     detectChangesAndCheck(fixture, 'foo baz');
+
+                     ListWrapper.remove(fixture.debugElement.componentInstance.arrExpr, 'baz');
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes when a reference changes',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.arrExpr = ['bar'];
+                     detectChangesAndCheck(fixture, 'bar');
+
+                     async.done();
+                   });
+             }));
+
+      it('should take initial classes into account when a reference changes',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.arrExpr = ['bar'];
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+                     async.done();
+                   });
+             }));
+
+      it('should ignore empty or blank class names',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+
+                     fixture.debugElement.componentInstance.arrExpr = ['', '  '];
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     async.done();
+                   });
+             }));
+
+      it('should trim blanks from class names',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div class="foo" [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+
+                     fixture.debugElement.componentInstance.arrExpr = [' bar  '];
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+                     async.done();
+                   });
+             }));
+
+
+      it('should allow multiple classes per item in arrays',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="arrExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+
+                     fixture.debugElement.componentInstance.arrExpr =
+                         ['foo bar baz', 'foo1 bar1   baz1'];
+                     detectChangesAndCheck(fixture, 'foo bar baz foo1 bar1 baz1');
+
+                     fixture.debugElement.componentInstance.arrExpr = ['foo bar   baz foobar'];
+                     detectChangesAndCheck(fixture, 'foo bar baz foobar');
+
+                     async.done();
+                   });
+             }));
+    });
+
+    describe('expressions evaluating to sets', () => {
+
+      it('should add and remove classes if the set instance changed',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="setExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     var setExpr = new Set<string>();
+                     setExpr.add('bar');
+                     fixture.debugElement.componentInstance.setExpr = setExpr;
+                     detectChangesAndCheck(fixture, 'bar');
+
+                     setExpr = new Set<string>();
+                     setExpr.add('baz');
+                     fixture.debugElement.componentInstance.setExpr = setExpr;
+                     detectChangesAndCheck(fixture, 'baz');
+
+                     async.done();
+                   });
+             }));
+    });
+    describe('expressions evaluating to string', () => {
+
+      it('should add classes specified in a string literal',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="'foo bar foo-bar fooBar'"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo bar foo-bar fooBar');
+                     async.done();
+                   });
+             }));
+
+      it('should add and remove classes based on changes to the expression',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="strExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.strExpr = 'foo bar';
+                     detectChangesAndCheck(fixture, 'foo bar');
+
+
+                     fixture.debugElement.componentInstance.strExpr = 'baz';
+                     detectChangesAndCheck(fixture, 'baz');
+
+                     async.done();
+                   });
+             }));
+
+      it('should remove active classes when switching from string to null',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="strExpr"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.strExpr = null;
+                     detectChangesAndCheck(fixture, '');
+
+                     async.done();
+                   });
+             }));
+
+      it('should take initial classes into account when switching from string to null',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div class="foo" [ngClass]="strExpr"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     fixture.debugElement.componentInstance.strExpr = null;
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     async.done();
+                   });
+             }));
+
+      it('should ignore empty and blank strings',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div class="foo" [ngClass]="strExpr"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.strExpr = '';
+                     detectChangesAndCheck(fixture, 'foo');
+
+                     async.done();
+                   });
+             }));
+
+    });
+
+    describe('cooperation with other class-changing constructs', () => {
+
+      it('should co-operate with the class attribute',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div [ngClass]="objExpr" class="init foo"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, 'init foo bar');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
+                     detectChangesAndCheck(fixture, 'init bar');
+
+                     fixture.debugElement.componentInstance.objExpr = null;
+                     detectChangesAndCheck(fixture, 'init foo');
+
+                     async.done();
+                   });
+             }));
+
+      it('should co-operate with the interpolated class attribute',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="objExpr" class="{{'init foo'}}"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, `init foo bar`);
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
+                     detectChangesAndCheck(fixture, `init bar`);
+
+                     fixture.debugElement.componentInstance.objExpr = null;
+                     detectChangesAndCheck(fixture, `init foo`);
+
+                     async.done();
+                   });
+             }));
+
+      it('should co-operate with the class attribute and binding to it',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = `<div [ngClass]="objExpr" class="init" [class]="'foo'"></div>`;
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, `init foo bar`);
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
+                     detectChangesAndCheck(fixture, `init bar`);
+
+                     fixture.debugElement.componentInstance.objExpr = null;
+                     detectChangesAndCheck(fixture, `init foo`);
+
+                     async.done();
+                   });
+             }));
+
+      it('should co-operate with the class attribute and class.name binding',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template =
+                   '<div class="init foo" [ngClass]="objExpr" [class.baz]="condition"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'init foo baz');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, 'init foo baz bar');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'foo', false);
+                     detectChangesAndCheck(fixture, 'init baz bar');
+
+                     fixture.debugElement.componentInstance.condition = false;
+                     detectChangesAndCheck(fixture, 'init bar');
+
+                     async.done();
+                   });
+             }));
+
+      it('should co-operate with initial class and class attribute binding when binding changes',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div class="init" [ngClass]="objExpr" [class]="strExpr"></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     detectChangesAndCheck(fixture, 'init foo');
+
+                     StringMapWrapper.set(
+                         fixture.debugElement.componentInstance.objExpr, 'bar', true);
+                     detectChangesAndCheck(fixture, 'init foo bar');
+
+                     fixture.debugElement.componentInstance.strExpr = 'baz';
+                     detectChangesAndCheck(fixture, 'init bar baz foo');
+
+                     fixture.debugElement.componentInstance.objExpr = null;
+                     detectChangesAndCheck(fixture, 'init baz');
+
+                     async.done();
+                   });
+             }));
+
+    });
+  })
+}
+
+@Component({selector: 'test-cmp', directives: [NgClass, NgFor], template: ''})
+class TestComponent {
+  condition: boolean = true;
+  items: any[];
+  arrExpr: string[] = ['foo'];
+  setExpr: Set<string> = new Set<string>();
+  objExpr = {'foo': true, 'bar': false};
+  strExpr = 'foo';
+
+  constructor() { this.setExpr.add('foo'); }
+}

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

@@ -0,0 +1,569 @@
+import {beforeEach, beforeEachProviders, ddescribe, describe, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {expect} from '@angular/platform-browser/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+
+import {ListWrapper} from '../../src/facade/collection';
+import {IS_DART} from '../../src/facade/lang';
+import {Component, TemplateRef, ContentChild} from '@angular/core';
+import {NgFor} from '@angular/common';
+import {NgIf} from '@angular/common';
+import {By} from '@angular/platform-browser/src/dom/debug/by';
+
+export function main() {
+  describe('ngFor', () => {
+    var TEMPLATE =
+        '<div><copy-me template="ngFor let item of items">{{item.toString()}};</copy-me></div>';
+
+    it('should reflect initial elements',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+                   async.done();
+                 });
+           }));
+
+    it('should reflect added elements',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   (<number[]>fixture.debugElement.componentInstance.items).push(3);
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
+                   async.done();
+                 });
+           }));
+
+    it('should reflect removed elements',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 1);
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;');
+                   async.done();
+                 });
+           }));
+
+    it('should reflect moved elements',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
+                   (<number[]>fixture.debugElement.componentInstance.items).push(1);
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('2;1;');
+                   async.done();
+                 });
+           }));
+
+    it('should reflect a mix of all changes (additions/removals/moves)',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5];
+                   fixture.detectChanges();
+
+                   fixture.debugElement.componentInstance.items = [6, 2, 7, 0, 4, 8];
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('6;2;7;0;4;8;');
+                   async.done();
+                 });
+           }));
+
+    it('should iterate over an array of objects',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   // INIT
+                   fixture.debugElement.componentInstance.items =
+                       [{'name': 'misko'}, {'name': 'shyam'}];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;');
+
+                   // GROW
+                   (<any[]>fixture.debugElement.componentInstance.items).push({'name': 'adam'});
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('misko;shyam;adam;');
+
+                   // SHRINK
+                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 2);
+                   ListWrapper.removeAt(fixture.debugElement.componentInstance.items, 0);
+                   fixture.detectChanges();
+
+                   expect(fixture.debugElement.nativeElement).toHaveText('shyam;');
+                   async.done();
+                 });
+           }));
+
+    it('should gracefully handle nulls',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+                   async.done();
+                 });
+           }));
+
+    it('should gracefully handle ref changing to null and back',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+
+                   fixture.debugElement.componentInstance.items = null;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   fixture.debugElement.componentInstance.items = [1, 2, 3];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;3;');
+                   async.done();
+                 });
+           }));
+
+    if (!IS_DART) {
+      it('should throw on non-iterable ref and suggest using an array',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               tcb.overrideTemplate(TestComponent, TEMPLATE)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.items = 'whaaa';
+                     try {
+                       fixture.detectChanges()
+                     } catch (e) {
+                       expect(e.message).toContain(
+                           `Cannot find a differ supporting object 'whaaa' of type 'string'. NgFor only supports binding to Iterables such as Arrays.`);
+                       async.done();
+                     }
+                   });
+             }));
+    }
+
+    it('should throw on ref changing to string',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('1;2;');
+
+                   fixture.debugElement.componentInstance.items = 'whaaa';
+                   expect(() => fixture.detectChanges()).toThrowError();
+                   async.done();
+                 });
+           }));
+
+    it('should works with duplicates',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, TEMPLATE)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   var a = new Foo();
+                   fixture.debugElement.componentInstance.items = [a, a];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('foo;foo;');
+                   async.done();
+                 });
+           }));
+
+    it('should repeat over nested arrays',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<div template="ngFor let item of items">' +
+                 '<div template="ngFor let subitem of item">' +
+                 '{{subitem}}-{{item.length}};' +
+                 '</div>|' +
+                 '</div>' +
+                 '</div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
+                   fixture.detectChanges();
+                   fixture.detectChanges();
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;|c-1;|');
+
+                   fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('e-1;|f-2;g-2;|');
+
+                   async.done();
+                 });
+           }));
+
+    it('should repeat over nested arrays with no intermediate element',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div><template ngFor let-item [ngForOf]="items">' +
+                 '<div template="ngFor let subitem of item">' +
+                 '{{subitem}}-{{item.length}};' +
+                 '</div></template></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [['a', 'b'], ['c']];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('a-2;b-2;c-1;');
+
+                   fixture.debugElement.componentInstance.items = [['e'], ['f', 'g']];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('e-1;f-2;g-2;');
+                   async.done();
+                 });
+           }));
+
+    it('should repeat over nested ngIf that are the last node in the ngFor temlate',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<div><template ngFor let-item [ngForOf]="items" let-i="index"><div>{{i}}|</div>` +
+                 `<div *ngIf="i % 2 == 0">even|</div></template></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   var el = fixture.debugElement.nativeElement;
+                   var items = [1];
+                   fixture.debugElement.componentInstance.items = items;
+                   fixture.detectChanges();
+                   expect(el).toHaveText('0|even|');
+
+                   items.push(1);
+                   fixture.detectChanges();
+                   expect(el).toHaveText('0|even|1|');
+
+                   items.push(1);
+                   fixture.detectChanges();
+                   expect(el).toHaveText('0|even|1|2|even|');
+
+                   async.done();
+                 });
+           }));
+
+    it('should display indices correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<div><copy-me template="ngFor: let item of items; let i=index">{{i.toString()}}</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
+
+                   fixture.debugElement.componentInstance.items = [1, 2, 6, 7, 4, 3, 5, 8, 9, 0];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('0123456789');
+                   async.done();
+                 });
+           }));
+
+    it('should display first item correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<div><copy-me template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('truefalsefalse');
+
+                   fixture.debugElement.componentInstance.items = [2, 1];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
+                   async.done();
+                 });
+           }));
+
+    it('should display last item correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<div><copy-me template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('falsefalsetrue');
+
+                   fixture.debugElement.componentInstance.items = [2, 1];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
+                   async.done();
+                 });
+           }));
+
+    it('should display even items correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<div><copy-me template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('truefalsetrue');
+
+                   fixture.debugElement.componentInstance.items = [2, 1];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('truefalse');
+                   async.done();
+                 });
+           }));
+
+    it('should display odd items correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 '<div><copy-me template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.items = [0, 1, 2, 3];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('falsetruefalsetrue');
+
+                   fixture.debugElement.componentInstance.items = [2, 1];
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('falsetrue');
+                   async.done();
+                 });
+           }));
+
+    it('should allow to use a custom template',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(
+                    TestComponent,
+                    '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>')
+                 .overrideTemplate(
+                     ComponentUsingTestComponent,
+                     '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
+                 .createAsync(ComponentUsingTestComponent)
+                 .then((fixture) => {
+                   var testComponent = fixture.debugElement.children[0];
+                   testComponent.componentInstance.items = ['a', 'b', 'c'];
+                   fixture.detectChanges();
+                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+
+                   async.done();
+                 });
+           }));
+
+    it('should use a default template if a custom one is null',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, `<ul><template ngFor let-item [ngForOf]="items"
+         [ngForTemplate]="contentTpl" let-i="index">{{i}}: {{item}};</template></ul>`)
+                 .overrideTemplate(ComponentUsingTestComponent, '<test-cmp></test-cmp>')
+                 .createAsync(ComponentUsingTestComponent)
+                 .then((fixture) => {
+                   var testComponent = fixture.debugElement.children[0];
+                   testComponent.componentInstance.items = ['a', 'b', 'c'];
+                   fixture.detectChanges();
+                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+
+                   async.done();
+                 });
+           }));
+
+    it('should use a custom template when both default and a custom one are present',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             tcb.overrideTemplate(TestComponent, `<ul><template ngFor let-item [ngForOf]="items"
+         [ngForTemplate]="contentTpl" let-i="index">{{i}}=> {{item}};</template></ul>`)
+                 .overrideTemplate(
+                     ComponentUsingTestComponent,
+                     '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
+                 .createAsync(ComponentUsingTestComponent)
+                 .then((fixture) => {
+                   var testComponent = fixture.debugElement.children[0];
+                   testComponent.componentInstance.items = ['a', 'b', 'c'];
+                   fixture.detectChanges();
+                   expect(testComponent.nativeElement).toHaveText('0: a;1: b;2: c;');
+
+                   async.done();
+                 });
+           }));
+
+    describe('track by', function() {
+      it('should not replace tracked items',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template =
+                   `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
+               <p>{{items[i]}}</p>
+              </template>`;
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     var buildItemList =
+                         () => {
+                           fixture.debugElement.componentInstance.items = [{'id': 'a'}];
+                           fixture.detectChanges();
+                           return fixture.debugElement.queryAll(By.css('p'))[0];
+                         }
+
+                     var firstP = buildItemList();
+                     var finalP = buildItemList();
+                     expect(finalP.nativeElement).toBe(firstP.nativeElement);
+                     async.done();
+                   });
+             }));
+      it('should update implicit local variable on view',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template =
+                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'blue'}];
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('blue');
+                     fixture.debugElement.componentInstance.items = [{'id': 'a', 'color': 'red'}];
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('red');
+                     async.done();
+                   });
+             }));
+      it('should move items around and keep them updated ',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template =
+                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.items =
+                         [{'id': 'a', 'color': 'blue'}, {'id': 'b', 'color': 'yellow'}];
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('blueyellow');
+                     fixture.debugElement.componentInstance.items =
+                         [{'id': 'b', 'color': 'orange'}, {'id': 'a', 'color': 'red'}];
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('orangered');
+                     async.done();
+                   });
+             }));
+
+      it('should handle added and removed items properly when tracking by index',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template =
+                   `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.items = ['a', 'b', 'c', 'd'];
+                     fixture.detectChanges();
+                     fixture.debugElement.componentInstance.items = ['e', 'f', 'g', 'h'];
+                     fixture.detectChanges();
+                     fixture.debugElement.componentInstance.items = ['e', 'f', 'h'];
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('efh');
+                     async.done();
+                   });
+             }));
+    });
+  });
+}
+
+class Foo {
+  toString() { return 'foo'; }
+}
+
+@Component({selector: 'test-cmp', directives: [NgFor, NgIf], template: ''})
+class TestComponent {
+  @ContentChild(TemplateRef) contentTpl: TemplateRef<Object>;
+  items: any;
+  constructor() { this.items = [1, 2]; }
+  trackById(index: number, item: any): string { return item['id']; }
+  trackByIndex(index: number, item: any): number { return index; }
+}
+
+@Component({selector: 'outer-cmp', directives: [TestComponent], template: ''})
+class ComponentUsingTestComponent {
+  items: any;
+  constructor() { this.items = [1, 2]; }
+}

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

@@ -0,0 +1,281 @@
+import {beforeEach, ddescribe, describe, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {expect} from '@angular/platform-browser/testing';
+import {TestComponentBuilder} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+
+import {Component} from '@angular/core';
+import {NgIf} from '@angular/common';
+
+import {IS_DART} from '../../src/facade/lang';
+
+export function main() {
+  describe('ngIf directive', () => {
+    it('should work in a template attribute',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, html)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+                   async.done();
+                 });
+           }));
+
+    it('should work in a template element',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var html =
+                 '<div><template [ngIf]="booleanCondition"><copy-me>hello2</copy-me></template></div>';
+
+             tcb.overrideTemplate(TestComponent, html)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('hello2');
+                   async.done();
+                 });
+           }));
+
+    it('should toggle node when condition changes',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
+
+             tcb.overrideTemplate(TestComponent, html)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.booleanCondition = false;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(0);
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   fixture.debugElement.componentInstance.booleanCondition = true;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+
+                   fixture.debugElement.componentInstance.booleanCondition = false;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(0);
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   async.done();
+                 });
+           }));
+
+    it('should handle nested if correctly',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var html =
+                 '<div><template [ngIf]="booleanCondition"><copy-me *ngIf="nestedBooleanCondition">hello</copy-me></template></div>';
+
+             tcb.overrideTemplate(TestComponent, html)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.booleanCondition = false;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(0);
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   fixture.debugElement.componentInstance.booleanCondition = true;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+
+                   fixture.debugElement.componentInstance.nestedBooleanCondition = false;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(0);
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   fixture.debugElement.componentInstance.nestedBooleanCondition = true;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('hello');
+
+                   fixture.debugElement.componentInstance.booleanCondition = false;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(0);
+                   expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                   async.done();
+                 });
+           }));
+
+    it('should update several nodes with if',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var html = '<div>' +
+                 '<copy-me template="ngIf numberCondition + 1 >= 2">helloNumber</copy-me>' +
+                 '<copy-me template="ngIf stringCondition == \'foo\'">helloString</copy-me>' +
+                 '<copy-me template="ngIf functionCondition(stringCondition, numberCondition)">helloFunction</copy-me>' +
+                 '</div>';
+
+             tcb.overrideTemplate(TestComponent, html)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(3);
+                   expect(getDOM().getText(fixture.debugElement.nativeElement))
+                       .toEqual('helloNumberhelloStringhelloFunction');
+
+                   fixture.debugElement.componentInstance.numberCondition = 0;
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('helloString');
+
+                   fixture.debugElement.componentInstance.numberCondition = 1;
+                   fixture.debugElement.componentInstance.stringCondition = 'bar';
+                   fixture.detectChanges();
+                   expect(getDOM()
+                              .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                              .length)
+                       .toEqual(1);
+                   expect(fixture.debugElement.nativeElement).toHaveText('helloNumber');
+                   async.done();
+                 });
+           }));
+
+
+    if (!IS_DART) {
+      it('should not add the element twice if the condition goes from true to true (JS)',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
+
+               tcb.overrideTemplate(TestComponent, html)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     expect(getDOM()
+                                .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                                .length)
+                         .toEqual(1);
+                     expect(fixture.debugElement.nativeElement).toHaveText('hello');
+
+                     fixture.debugElement.componentInstance.numberCondition = 2;
+                     fixture.detectChanges();
+                     expect(getDOM()
+                                .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                                .length)
+                         .toEqual(1);
+                     expect(fixture.debugElement.nativeElement).toHaveText('hello');
+
+                     async.done();
+                   });
+             }));
+
+      it('should not recreate the element if the condition goes from true to true (JS)',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
+
+               tcb.overrideTemplate(TestComponent, html)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     getDOM().addClass(
+                         getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'),
+                         'foo');
+
+                     fixture.debugElement.componentInstance.numberCondition = 2;
+                     fixture.detectChanges();
+                     expect(
+                         getDOM().hasClass(
+                             getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'),
+                             'foo'))
+                         .toBe(true);
+
+                     async.done();
+                   });
+             }));
+    }
+
+    if (IS_DART) {
+      it('should not create the element if the condition is not a boolean (DART)',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
+
+               tcb.overrideTemplate(TestComponent, html)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     expect(() => fixture.detectChanges()).toThrowError();
+                     expect(getDOM()
+                                .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                                .length)
+                         .toEqual(0);
+                     expect(fixture.debugElement.nativeElement).toHaveText('');
+                     async.done();
+                   });
+             }));
+    }
+
+  });
+}
+
+@Component({selector: 'test-cmp', directives: [NgIf], template: ''})
+class TestComponent {
+  booleanCondition: boolean;
+  nestedBooleanCondition: boolean;
+  numberCondition: number;
+  stringCondition: string;
+  functionCondition: Function;
+  constructor() {
+    this.booleanCondition = true;
+    this.nestedBooleanCondition = true;
+    this.numberCondition = 1;
+    this.stringCondition = 'foo';
+    this.functionCondition = function(s: any, n: any): boolean { return s == 'foo' && n == 1; };
+  }
+}

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

@@ -0,0 +1,155 @@
+import {beforeEachProviders, beforeEach, ddescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder} from '@angular/compiler/testing';
+
+import {Component, Injectable} from '@angular/core';
+import {NgPlural, NgPluralCase, NgLocalization} from '@angular/common';
+
+export function main() {
+  describe('switch', () => {
+    beforeEachProviders(() => [{provide: NgLocalization, useClass: TestLocalizationMap}]);
+
+    it('should display the template according to the exact value',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<ul [ngPlural]="switchValue">' +
+                 '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
+                 '<template ngPluralCase="=1"><li>you have one message.</li></template>' +
+                 '</ul></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.switchValue = 0;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
+
+                   fixture.debugElement.componentInstance.switchValue = 1;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+
+                   async.done();
+                 });
+           }));
+
+    it('should be applicable to <ng-container> elements',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<ng-container [ngPlural]="switchValue">' +
+                 '<template ngPluralCase="=0">you have no messages.</template>' +
+                 '<template ngPluralCase="=1">you have one message.</template>' +
+                 '</ng-container></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.switchValue = 0;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have no messages.');
+
+                   fixture.debugElement.componentInstance.switchValue = 1;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have one message.');
+
+                   async.done();
+                 });
+           }));
+
+    it('should display the template according to the category',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<ul [ngPlural]="switchValue">' +
+                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+                 '<template ngPluralCase="many"><li>you have many messages.</li></template>' +
+                 '</ul></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.switchValue = 2;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement)
+                       .toHaveText('you have a few messages.');
+
+                   fixture.debugElement.componentInstance.switchValue = 8;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have many messages.');
+
+                   async.done();
+                 });
+           }));
+
+    it('should default to other when no matches are found',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<ul [ngPlural]="switchValue">' +
+                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+                 '<template ngPluralCase="other"><li>default message.</li></template>' +
+                 '</ul></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.switchValue = 100;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('default message.');
+
+                   async.done();
+                 });
+           }));
+
+    it('should prioritize value matches over category matches',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>' +
+                 '<ul [ngPlural]="switchValue">' +
+                 '<template ngPluralCase="few"><li>you have a few messages.</li></template>' +
+                 '<template ngPluralCase="=2">you have two messages.</template>' +
+                 '</ul></div>';
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.switchValue = 2;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('you have two messages.');
+
+                   fixture.debugElement.componentInstance.switchValue = 3;
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement)
+                       .toHaveText('you have a few messages.');
+
+                   async.done();
+                 });
+           }));
+  });
+}
+
+
+@Injectable()
+export class TestLocalizationMap extends NgLocalization {
+  getPluralCategory(value: number): string {
+    if (value > 1 && value < 4) {
+      return 'few';
+    } else if (value >= 4 && value < 10) {
+      return 'many';
+    } else {
+      return 'other';
+    }
+  }
+}
+
+
+@Component({selector: 'test-cmp', directives: [NgPluralCase, NgPlural], template: ''})
+class TestComponent {
+  switchValue: number = null;
+}

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

@@ -0,0 +1,157 @@
+import {beforeEach, beforeEachProviders, ddescribe, xdescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+
+import {StringMapWrapper} from '../../src/facade/collection';
+
+import {Component} from '@angular/core';
+
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {NgStyle} from '@angular/common/src/directives/ng_style';
+
+export function main() {
+  describe('binding to CSS styles', () => {
+
+    it('should add styles specified in an object literal',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<div [ngStyle]="{'max-width': '40px'}"></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('40px');
+
+                   async.done();
+                 });
+           }));
+
+    it('should add and change styles specified in an object expression',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<div [ngStyle]="expr"></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   var expr: Map<string, any>;
+
+                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('40px');
+
+                   expr = fixture.debugElement.componentInstance.expr;
+                   (expr as any)['max-width'] = '30%';
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('30%');
+
+                   async.done();
+                 });
+           }));
+
+    it('should remove styles when deleting a key in an object expression',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<div [ngStyle]="expr"></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('40px');
+
+                   StringMapWrapper.delete(
+                       fixture.debugElement.componentInstance.expr, 'max-width');
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('');
+
+                   async.done();
+                 });
+           }));
+
+    it('should co-operate with the style attribute',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<div style="font-size: 12px" [ngStyle]="expr"></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('40px');
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'font-size'))
+                       .toEqual('12px');
+
+                   StringMapWrapper.delete(
+                       fixture.debugElement.componentInstance.expr, 'max-width');
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('');
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'font-size'))
+                       .toEqual('12px');
+
+                   async.done();
+                 });
+           }));
+
+    it('should co-operate with the style.[styleName]="expr" special-case in the compiler',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<div [style.font-size.px]="12" [ngStyle]="expr"></div>`;
+
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('40px');
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'font-size'))
+                       .toEqual('12px');
+
+                   StringMapWrapper.delete(
+                       fixture.debugElement.componentInstance.expr, 'max-width');
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'font-size'))
+                       .toEqual('12px');
+
+                   fixture.detectChanges();
+                   expect(getDOM().getStyle(
+                              fixture.debugElement.children[0].nativeElement, 'max-width'))
+                       .toEqual('');
+
+                   async.done();
+                 });
+           }));
+  })
+}
+
+@Component({selector: 'test-cmp', directives: [NgStyle], template: ''})
+class TestComponent {
+  expr: any;
+}

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

@@ -0,0 +1,186 @@
+import {beforeEach, ddescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {Component} from '@angular/core';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+
+import {NgSwitch, NgSwitchCase, NgSwitchDefault} from '@angular/common';
+
+export function main() {
+  describe('switch', () => {
+    describe('switch value changes', () => {
+      it('should switch amongst when values',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div>' +
+                   '<ul [ngSwitch]="switchValue">' +
+                   '<template ngSwitchCase="a"><li>when a</li></template>' +
+                   '<template ngSwitchCase="b"><li>when b</li></template>' +
+                   '</ul></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                     fixture.debugElement.componentInstance.switchValue = 'a';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+
+                     fixture.debugElement.componentInstance.switchValue = 'b';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when b');
+
+                     async.done();
+                   });
+             }));
+
+      // TODO(robwormald): deprecate and remove
+      it('should switch amongst when values using switchWhen',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div>' +
+                   '<ul [ngSwitch]="switchValue">' +
+                   '<template ngSwitchWhen="a"><li>when a</li></template>' +
+                   '<template ngSwitchWhen="b"><li>when b</li></template>' +
+                   '</ul></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('');
+
+                     fixture.debugElement.componentInstance.switchValue = 'a';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+
+                     fixture.debugElement.componentInstance.switchValue = 'b';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when b');
+
+                     async.done();
+                   });
+             }));
+
+      it('should switch amongst when values with fallback to default',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div>' +
+                   '<ul [ngSwitch]="switchValue">' +
+                   '<li template="ngSwitchCase \'a\'">when a</li>' +
+                   '<li template="ngSwitchDefault">when default</li>' +
+                   '</ul></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when default');
+
+                     fixture.debugElement.componentInstance.switchValue = 'a';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when a');
+
+                     fixture.debugElement.componentInstance.switchValue = 'b';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when default');
+
+                     async.done();
+                   });
+             }));
+
+      it('should support multiple whens with the same value',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div>' +
+                   '<ul [ngSwitch]="switchValue">' +
+                   '<template ngSwitchCase="a"><li>when a1;</li></template>' +
+                   '<template ngSwitchCase="b"><li>when b1;</li></template>' +
+                   '<template ngSwitchCase="a"><li>when a2;</li></template>' +
+                   '<template ngSwitchCase="b"><li>when b2;</li></template>' +
+                   '<template ngSwitchDefault><li>when default1;</li></template>' +
+                   '<template ngSwitchDefault><li>when default2;</li></template>' +
+                   '</ul></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement)
+                         .toHaveText('when default1;when default2;');
+
+                     fixture.debugElement.componentInstance.switchValue = 'a';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when a1;when a2;');
+
+                     fixture.debugElement.componentInstance.switchValue = 'b';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when b1;when b2;');
+
+                     async.done();
+                   });
+             }));
+    });
+
+    describe('when values changes', () => {
+      it('should switch amongst when values',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               var template = '<div>' +
+                   '<ul [ngSwitch]="switchValue">' +
+                   '<template [ngSwitchCase]="when1"><li>when 1;</li></template>' +
+                   '<template [ngSwitchCase]="when2"><li>when 2;</li></template>' +
+                   '<template ngSwitchDefault><li>when default;</li></template>' +
+                   '</ul></div>';
+
+               tcb.overrideTemplate(TestComponent, template)
+                   .createAsync(TestComponent)
+                   .then((fixture) => {
+                     fixture.debugElement.componentInstance.when1 = 'a';
+                     fixture.debugElement.componentInstance.when2 = 'b';
+                     fixture.debugElement.componentInstance.switchValue = 'a';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
+
+                     fixture.debugElement.componentInstance.switchValue = 'b';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when 2;');
+
+                     fixture.debugElement.componentInstance.switchValue = 'c';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when default;');
+
+                     fixture.debugElement.componentInstance.when1 = 'c';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when 1;');
+
+                     fixture.debugElement.componentInstance.when1 = 'd';
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('when default;');
+
+                     async.done();
+                   });
+             }));
+    });
+  });
+}
+
+@Component(
+    {selector: 'test-cmp', directives: [NgSwitch, NgSwitchCase, NgSwitchDefault], template: ''})
+class TestComponent {
+  switchValue: any;
+  when1: any;
+  when2: any;
+
+  constructor() {
+    this.switchValue = null;
+    this.when1 = null;
+    this.when2 = null;
+  }
+}

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

@@ -0,0 +1,210 @@
+import {beforeEach, ddescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {Component, Directive, TemplateRef, ContentChildren, QueryList} from '@angular/core';
+import {NgTemplateOutlet} from '@angular/common';
+
+export function main() {
+  describe('insert', () => {
+    it('should do nothing if templateRef is null',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = `<template [ngTemplateOutlet]="null"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('');
+
+                   async.done();
+                 });
+           }));
+
+    it('should insert content specified by TemplateRef',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('');
+
+                   var refs = fixture.debugElement.children[0].references['refs'];
+
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('foo');
+
+                   async.done();
+                 });
+           }));
+
+    it('should clear content if TemplateRef becomes null',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   fixture.detectChanges();
+                   var refs = fixture.debugElement.children[0].references['refs'];
+
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('foo');
+
+                   fixture.componentInstance.currentTplRef = null;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('');
+
+                   async.done();
+                 });
+           }));
+
+    it('should swap content if TemplateRef changes',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   fixture.detectChanges();
+                   var refs = fixture.debugElement.children[0].references['refs'];
+
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('foo');
+
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.last;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('bar');
+
+                   async.done();
+                 });
+           }));
+
+    it('should display template if context is null',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="null"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('');
+
+                   var refs = fixture.debugElement.children[0].references['refs'];
+
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+                   fixture.detectChanges();
+                   expect(fixture.nativeElement).toHaveText('foo');
+
+                   async.done();
+                 });
+           }));
+
+    it('should reflect initial context and changes',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template let-foo="foo"><span>{{foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   var refs = fixture.debugElement.children[0].references['refs'];
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('bar');
+
+                   fixture.componentInstance.context.foo = 'alter-bar';
+
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('alter-bar');
+
+                   async.done();
+                 });
+           }));
+
+    it('should reflect user defined $implicit property in the context',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template let-ctx><span>{{ctx.foo}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   var refs = fixture.debugElement.children[0].references['refs'];
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+
+                   fixture.componentInstance.context = {
+                     $implicit: fixture.componentInstance.context
+                   };
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('bar');
+
+                   async.done();
+                 });
+           }));
+
+    it('should reflect context re-binding',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template =
+                 `<tpl-refs #refs="tplRefs"><template let-shawshank="shawshank"><span>{{shawshank}}</span></template></tpl-refs><template [ngTemplateOutlet]="currentTplRef" [ngOutletContext]="context"></template>`;
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   var refs = fixture.debugElement.children[0].references['refs'];
+                   fixture.componentInstance.currentTplRef = refs.tplRefs.first;
+                   fixture.componentInstance.context = {shawshank: 'brooks'};
+
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('brooks');
+
+                   fixture.componentInstance.context = {shawshank: 'was here'};
+
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('was here');
+
+                   async.done();
+                 });
+           }));
+  });
+}
+
+
+@Directive({selector: 'tpl-refs', exportAs: 'tplRefs'})
+class CaptureTplRefs {
+  @ContentChildren(TemplateRef) tplRefs: QueryList<TemplateRef<any>>;
+}
+
+@Component({selector: 'test-cmp', directives: [NgTemplateOutlet, CaptureTplRefs], template: ''})
+class TestComponent {
+  currentTplRef: TemplateRef<any>;
+  context: any = {foo: 'bar'};
+}

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

@@ -0,0 +1,68 @@
+import {beforeEach, ddescribe, describe, expect, iit, inject, it, xit,} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {Component, Directive} from '@angular/core';
+import {ElementRef} from '@angular/core/src/linker/element_ref';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('non-bindable', () => {
+    it('should not interpolate children',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div>{{text}}<span ngNonBindable>{{text}}</span></div>';
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   expect(fixture.debugElement.nativeElement).toHaveText('foo{{text}}');
+                   async.done();
+                 });
+           }));
+
+    it('should ignore directives on child nodes',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div ngNonBindable><span id=child test-dec>{{text}}</span></div>';
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+
+                   // We must use getDOM().querySelector instead of fixture.query here
+                   // since the elements inside are not compiled.
+                   var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+                   expect(getDOM().hasClass(span, 'compiled')).toBeFalsy();
+                   async.done();
+                 });
+           }));
+
+    it('should trigger directives on the same node',
+       inject(
+           [TestComponentBuilder, AsyncTestCompleter],
+           (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+             var template = '<div><span id=child ngNonBindable test-dec>{{text}}</span></div>';
+             tcb.overrideTemplate(TestComponent, template)
+                 .createAsync(TestComponent)
+                 .then((fixture) => {
+                   fixture.detectChanges();
+                   var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+                   expect(getDOM().hasClass(span, 'compiled')).toBeTruthy();
+                   async.done();
+                 });
+           }));
+  })
+}
+
+@Directive({selector: '[test-dec]'})
+class TestDirective {
+  constructor(el: ElementRef) { getDOM().addClass(el.nativeElement, 'compiled'); }
+}
+
+@Component({selector: 'test-cmp', directives: [TestDirective], template: ''})
+class TestComponent {
+  text: string;
+  constructor() { this.text = 'foo'; }
+}

modules/@angular/common/test/forms-deprecated/directives_spec.ts

@@ -1,65 +1,34 @@
-import {
-  ddescribe,
-  describe,
-  fakeAsync,
-  flushMicrotasks,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach,
-  el,
-  AsyncTestCompleter,
-  inject,
-  tick
-} from 'angular2/testing_internal';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, inject, it, xit} from '@angular/core/testing/testing_internal';
+
+import {fakeAsync, flushMicrotasks, Log, tick,} from '@angular/core/testing';
 
 import {SpyNgControl, SpyValueAccessor} from '../spies';
 
-import {QueryList} from 'angular2/core';
-
-import {
-  ControlGroup,
-  Control,
-  NgControlName,
-  NgControlGroup,
-  NgFormModel,
-  ControlValueAccessor,
-  Validators,
-  NgForm,
-  NgModel,
-  NgFormControl,
-  NgControl,
-  DefaultValueAccessor,
-  CheckboxControlValueAccessor,
-  SelectControlValueAccessor,
-  Validator
-} from 'angular2/common';
+import {ControlGroup, Control, NgControlName, NgControlGroup, NgFormModel, ControlValueAccessor, Validators, NgForm, NgModel, NgFormControl, NgControl, DefaultValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, Validator} from '@angular/common/src/forms-deprecated';
 
 
-import {selectValueAccessor, composeValidators} from 'angular2/src/common/forms/directives/shared';
-import {TimerWrapper} from 'angular2/src/facade/async';
-import {PromiseWrapper} from 'angular2/src/facade/promise';
-import {SimpleChange} from 'angular2/src/core/change_detection';
+import {selectValueAccessor, composeValidators} from '@angular/common/src/forms-deprecated/directives/shared';
+import {TimerWrapper} from '../../src/facade/async';
+import {PromiseWrapper} from '../../src/facade/promise';
+import {SimpleChange} from '@angular/core/src/change_detection';
 
 class DummyControlValueAccessor implements ControlValueAccessor {
-  writtenValue;
+  writtenValue: any /** TODO #9100 */;
 
-  registerOnChange(fn) {}
-  registerOnTouched(fn) {}
+  registerOnChange(fn: any /** TODO #9100 */) {}
+  registerOnTouched(fn: any /** TODO #9100 */) {}
 
   writeValue(obj: any): void { this.writtenValue = obj; }
 }
 
 class CustomValidatorDirective implements Validator {
-  validate(c: Control): {[key: string]: any} { return {"custom": true}; }
+  validate(c: Control): {[key: string]: any} { return {'custom': true}; }
 }
 
-function asyncValidator(expected, timeout = 0) {
-  return (c) => {
+function asyncValidator(expected: any /** TODO #9100 */, timeout = 0) {
+  return (c: any /** TODO #9100 */) => {
     var completer = PromiseWrapper.completer();
-    var res = c.value != expected ? {"async": true} : null;
+    var res = c.value != expected ? {'async': true} : null;
     if (timeout == 0) {
       completer.resolve(res);
     } else {
@@ -70,91 +39,93 @@ function asyncValidator(expected, timeout = 0) {
 }
 
 export function main() {
-  describe("Form Directives", () => {
-    var defaultAccessor;
+  describe('Form Directives', () => {
+    var defaultAccessor: DefaultValueAccessor;
 
     beforeEach(() => { defaultAccessor = new DefaultValueAccessor(null, null); });
 
-    describe("shared", () => {
-      describe("selectValueAccessor", () => {
+    describe('shared', () => {
+      describe('selectValueAccessor', () => {
         var dir: NgControl;
 
         beforeEach(() => { dir = <any>new SpyNgControl(); });
 
-        it("should throw when given an empty array",
+        it('should throw when given an empty array',
            () => { expect(() => selectValueAccessor(dir, [])).toThrowError(); });
 
-        it("should return the default value accessor when no other provided",
+        it('should return the default value accessor when no other provided',
            () => { expect(selectValueAccessor(dir, [defaultAccessor])).toEqual(defaultAccessor); });
 
-        it("should return checkbox accessor when provided", () => {
+        it('should return checkbox accessor when provided', () => {
           var checkboxAccessor = new CheckboxControlValueAccessor(null, null);
-          expect(selectValueAccessor(dir, [defaultAccessor, checkboxAccessor]))
-              .toEqual(checkboxAccessor);
+          expect(selectValueAccessor(dir, [
+            defaultAccessor, checkboxAccessor
+          ])).toEqual(checkboxAccessor);
         });
 
-        it("should return select accessor when provided", () => {
-          var selectAccessor = new SelectControlValueAccessor(null, null, new QueryList<any>());
-          expect(selectValueAccessor(dir, [defaultAccessor, selectAccessor]))
-              .toEqual(selectAccessor);
+        it('should return select accessor when provided', () => {
+          var selectAccessor = new SelectControlValueAccessor(null, null);
+          expect(selectValueAccessor(dir, [
+            defaultAccessor, selectAccessor
+          ])).toEqual(selectAccessor);
         });
 
-        it("should throw when more than one build-in accessor is provided", () => {
+        it('should throw when more than one build-in accessor is provided', () => {
           var checkboxAccessor = new CheckboxControlValueAccessor(null, null);
-          var selectAccessor = new SelectControlValueAccessor(null, null, new QueryList<any>());
+          var selectAccessor = new SelectControlValueAccessor(null, null);
           expect(() => selectValueAccessor(dir, [checkboxAccessor, selectAccessor])).toThrowError();
         });
 
-        it("should return custom accessor when provided", () => {
+        it('should return custom accessor when provided', () => {
           var customAccessor = new SpyValueAccessor();
           var checkboxAccessor = new CheckboxControlValueAccessor(null, null);
-          expect(selectValueAccessor(dir, [defaultAccessor, customAccessor, checkboxAccessor]))
+          expect(selectValueAccessor(dir, <any>[defaultAccessor, customAccessor, checkboxAccessor]))
               .toEqual(customAccessor);
         });
 
-        it("should throw when more than one custom accessor is provided", () => {
+        it('should throw when more than one custom accessor is provided', () => {
           var customAccessor: ControlValueAccessor = <any>new SpyValueAccessor();
           expect(() => selectValueAccessor(dir, [customAccessor, customAccessor])).toThrowError();
         });
       });
 
-      describe("composeValidators", () => {
-        it("should compose functions", () => {
-          var dummy1 = (_) => ({"dummy1": true});
-          var dummy2 = (_) => ({"dummy2": true});
+      describe('composeValidators', () => {
+        it('should compose functions', () => {
+          var dummy1 = (_: any /** TODO #9100 */) => ({'dummy1': true});
+          var dummy2 = (_: any /** TODO #9100 */) => ({'dummy2': true});
           var v = composeValidators([dummy1, dummy2]);
-          expect(v(new Control(""))).toEqual({"dummy1": true, "dummy2": true});
+          expect(v(new Control(''))).toEqual({'dummy1': true, 'dummy2': true});
         });
 
-        it("should compose validator directives", () => {
-          var dummy1 = (_) => ({"dummy1": true});
+        it('should compose validator directives', () => {
+          var dummy1 = (_: any /** TODO #9100 */) => ({'dummy1': true});
           var v = composeValidators([dummy1, new CustomValidatorDirective()]);
-          expect(v(new Control(""))).toEqual({"dummy1": true, "custom": true});
+          expect(v(new Control(''))).toEqual({'dummy1': true, 'custom': true});
         });
       });
     });
 
-    describe("NgFormModel", () => {
-      var form;
+    describe('NgFormModel', () => {
+      var form: any /** TODO #9100 */;
       var formModel: ControlGroup;
-      var loginControlDir;
+      var loginControlDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         form = new NgFormModel([], []);
         formModel = new ControlGroup({
-          "login": new Control(),
-          "passwords":
-              new ControlGroup({"password": new Control(), "passwordConfirm": new Control()})
+          'login': new Control(),
+          'passwords':
+              new ControlGroup({'password': new Control(), 'passwordConfirm': new Control()})
         });
         form.form = formModel;
 
-        loginControlDir = new NgControlName(form, [Validators.required],
-                                            [asyncValidator("expected")], [defaultAccessor]);
-        loginControlDir.name = "login";
+        loginControlDir = new NgControlName(
+            form, [Validators.required], [asyncValidator('expected')], [defaultAccessor]);
+        loginControlDir.name = 'login';
         loginControlDir.valueAccessor = new DummyControlValueAccessor();
       });
 
-      it("should reexport control properties", () => {
+      it('should reexport control properties', () => {
         expect(form.control).toBe(formModel);
         expect(form.value).toBe(formModel.value);
         expect(form.valid).toBe(formModel.valid);
@@ -165,148 +136,150 @@ export function main() {
         expect(form.untouched).toBe(formModel.untouched);
       });
 
-      describe("addControl", () => {
-        it("should throw when no control found", () => {
+      describe('addControl', () => {
+        it('should throw when no control found', () => {
           var dir = new NgControlName(form, null, null, [defaultAccessor]);
-          dir.name = "invalidName";
+          dir.name = 'invalidName';
 
           expect(() => form.addControl(dir))
-              .toThrowError(new RegExp("Cannot find control 'invalidName'"));
+              .toThrowError(new RegExp('Cannot find control \'invalidName\''));
         });
 
-        it("should throw when no value accessor", () => {
+        it('should throw when no value accessor', () => {
           var dir = new NgControlName(form, null, null, null);
-          dir.name = "login";
+          dir.name = 'login';
 
           expect(() => form.addControl(dir))
-              .toThrowError(new RegExp("No value accessor for 'login'"));
+              .toThrowError(new RegExp('No value accessor for \'login\''));
         });
 
-        it("should set up validators", fakeAsync(() => {
+        it('should set up validators', fakeAsync(() => {
              form.addControl(loginControlDir);
 
              // sync validators are set
-             expect(formModel.hasError("required", ["login"])).toBe(true);
-             expect(formModel.hasError("async", ["login"])).toBe(false);
+             expect(formModel.hasError('required', ['login'])).toBe(true);
+             expect(formModel.hasError('async', ['login'])).toBe(false);
 
-             (<Control>formModel.find(["login"])).updateValue("invalid value");
+             (<Control>formModel.find(['login'])).updateValue('invalid value');
 
              // sync validator passes, running async validators
              expect(formModel.pending).toBe(true);
 
              tick();
 
-             expect(formModel.hasError("required", ["login"])).toBe(false);
-             expect(formModel.hasError("async", ["login"])).toBe(true);
+             expect(formModel.hasError('required', ['login'])).toBe(false);
+             expect(formModel.hasError('async', ['login'])).toBe(true);
            }));
 
-        it("should write value to the DOM", () => {
-          (<Control>formModel.find(["login"])).updateValue("initValue");
+        it('should write value to the DOM', () => {
+          (<Control>formModel.find(['login'])).updateValue('initValue');
 
           form.addControl(loginControlDir);
 
-          expect((<any>loginControlDir.valueAccessor).writtenValue).toEqual("initValue");
+          expect((<any>loginControlDir.valueAccessor).writtenValue).toEqual('initValue');
         });
 
-        it("should add the directive to the list of directives included in the form", () => {
+        it('should add the directive to the list of directives included in the form', () => {
           form.addControl(loginControlDir);
           expect(form.directives).toEqual([loginControlDir]);
         });
       });
 
-      describe("addControlGroup", () => {
-        var matchingPasswordsValidator = (g) => {
-          if (g.controls["password"].value != g.controls["passwordConfirm"].value) {
-            return {"differentPasswords": true};
+      describe('addControlGroup', () => {
+        var matchingPasswordsValidator = (g: any /** TODO #9100 */) => {
+          if (g.controls['password'].value != g.controls['passwordConfirm'].value) {
+            return {'differentPasswords': true};
           } else {
             return null;
           }
         };
 
-        it("should set up validator", fakeAsync(() => {
-             var group = new NgControlGroup(form, [matchingPasswordsValidator],
-                                            [asyncValidator('expected')]);
-             group.name = "passwords";
+        it('should set up validator', fakeAsync(() => {
+             var group = new NgControlGroup(
+                 form, [matchingPasswordsValidator], [asyncValidator('expected')]);
+             group.name = 'passwords';
              form.addControlGroup(group);
 
-             (<Control>formModel.find(["passwords", "password"])).updateValue("somePassword");
-             (<Control>formModel.find(["passwords", "passwordConfirm"]))
-                 .updateValue("someOtherPassword");
+             (<Control>formModel.find(['passwords', 'password'])).updateValue('somePassword');
+             (<Control>formModel.find([
+               'passwords', 'passwordConfirm'
+             ])).updateValue('someOtherPassword');
 
              // sync validators are set
-             expect(formModel.hasError("differentPasswords", ["passwords"])).toEqual(true);
+             expect(formModel.hasError('differentPasswords', ['passwords'])).toEqual(true);
 
-             (<Control>formModel.find(["passwords", "passwordConfirm"]))
-                 .updateValue("somePassword");
+             (<Control>formModel.find([
+               'passwords', 'passwordConfirm'
+             ])).updateValue('somePassword');
 
              // sync validators pass, running async validators
              expect(formModel.pending).toBe(true);
 
              tick();
 
-             expect(formModel.hasError("async", ["passwords"])).toBe(true);
+             expect(formModel.hasError('async', ['passwords'])).toBe(true);
            }));
       });
 
-      describe("removeControl", () => {
-        it("should remove the directive to the list of directives included in the form", () => {
+      describe('removeControl', () => {
+        it('should remove the directive to the list of directives included in the form', () => {
           form.addControl(loginControlDir);
           form.removeControl(loginControlDir);
           expect(form.directives).toEqual([]);
         });
       });
 
-      describe("ngOnChanges", () => {
-        it("should update dom values of all the directives", () => {
+      describe('ngOnChanges', () => {
+        it('should update dom values of all the directives', () => {
           form.addControl(loginControlDir);
 
-          (<Control>formModel.find(["login"])).updateValue("new value");
+          (<Control>formModel.find(['login'])).updateValue('new value');
 
           form.ngOnChanges({});
 
-          expect((<any>loginControlDir.valueAccessor).writtenValue).toEqual("new value");
+          expect((<any>loginControlDir.valueAccessor).writtenValue).toEqual('new value');
         });
 
-        it("should set up a sync validator", () => {
-          var formValidator = (c) => ({"custom": true});
+        it('should set up a sync validator', () => {
+          var formValidator = (c: any /** TODO #9100 */) => ({'custom': true});
           var f = new NgFormModel([formValidator], []);
           f.form = formModel;
-          f.ngOnChanges({"form": new SimpleChange(null, null)});
+          f.ngOnChanges({'form': new SimpleChange(null, null)});
 
-          expect(formModel.errors).toEqual({"custom": true});
+          expect(formModel.errors).toEqual({'custom': true});
         });
 
-        it("should set up an async validator", fakeAsync(() => {
-             var f = new NgFormModel([], [asyncValidator("expected")]);
+        it('should set up an async validator', fakeAsync(() => {
+             var f = new NgFormModel([], [asyncValidator('expected')]);
              f.form = formModel;
-             f.ngOnChanges({"form": new SimpleChange(null, null)});
+             f.ngOnChanges({'form': new SimpleChange(null, null)});
 
              tick();
 
-             expect(formModel.errors).toEqual({"async": true});
+             expect(formModel.errors).toEqual({'async': true});
            }));
       });
     });
 
-    describe("NgForm", () => {
-      var form;
+    describe('NgForm', () => {
+      var form: any /** TODO #9100 */;
       var formModel: ControlGroup;
-      var loginControlDir;
-      var personControlGroupDir;
+      var loginControlDir: any /** TODO #9100 */;
+      var personControlGroupDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         form = new NgForm([], []);
         formModel = form.form;
 
         personControlGroupDir = new NgControlGroup(form, [], []);
-        personControlGroupDir.name = "person";
+        personControlGroupDir.name = 'person';
 
         loginControlDir = new NgControlName(personControlGroupDir, null, null, [defaultAccessor]);
-        loginControlDir.name = "login";
+        loginControlDir.name = 'login';
         loginControlDir.valueAccessor = new DummyControlValueAccessor();
       });
 
-      it("should reexport control properties", () => {
+      it('should reexport control properties', () => {
         expect(form.control).toBe(formModel);
         expect(form.value).toBe(formModel.value);
         expect(form.valid).toBe(formModel.valid);
@@ -317,21 +290,21 @@ export function main() {
         expect(form.untouched).toBe(formModel.untouched);
       });
 
-      describe("addControl & addControlGroup", () => {
-        it("should create a control with the given name", fakeAsync(() => {
+      describe('addControl & addControlGroup', () => {
+        it('should create a control with the given name', fakeAsync(() => {
              form.addControlGroup(personControlGroupDir);
              form.addControl(loginControlDir);
 
              flushMicrotasks();
 
-             expect(formModel.find(["person", "login"])).not.toBeNull;
+             expect(formModel.find(['person', 'login'])).not.toBeNull;
            }));
 
         // should update the form's value and validity
       });
 
-      describe("removeControl & removeControlGroup", () => {
-        it("should remove control", fakeAsync(() => {
+      describe('removeControl & removeControlGroup', () => {
+        it('should remove control', fakeAsync(() => {
              form.addControlGroup(personControlGroupDir);
              form.addControl(loginControlDir);
 
@@ -340,45 +313,45 @@ export function main() {
 
              flushMicrotasks();
 
-             expect(formModel.find(["person"])).toBeNull();
-             expect(formModel.find(["person", "login"])).toBeNull();
+             expect(formModel.find(['person'])).toBeNull();
+             expect(formModel.find(['person', 'login'])).toBeNull();
            }));
 
         // should update the form's value and validity
       });
 
-      it("should set up sync validator", fakeAsync(() => {
-           var formValidator = (c) => ({"custom": true});
+      it('should set up sync validator', fakeAsync(() => {
+           var formValidator = (c: any /** TODO #9100 */) => ({'custom': true});
            var f = new NgForm([formValidator], []);
 
            tick();
 
-           expect(f.form.errors).toEqual({"custom": true});
+           expect(f.form.errors).toEqual({'custom': true});
          }));
 
-      it("should set up async validator", fakeAsync(() => {
-           var f = new NgForm([], [asyncValidator("expected")]);
+      it('should set up async validator', fakeAsync(() => {
+           var f = new NgForm([], [asyncValidator('expected')]);
 
            tick();
 
-           expect(f.form.errors).toEqual({"async": true});
+           expect(f.form.errors).toEqual({'async': true});
          }));
     });
 
-    describe("NgControlGroup", () => {
-      var formModel;
-      var controlGroupDir;
+    describe('NgControlGroup', () => {
+      var formModel: any /** TODO #9100 */;
+      var controlGroupDir: any /** TODO #9100 */;
 
       beforeEach(() => {
-        formModel = new ControlGroup({"login": new Control(null)});
+        formModel = new ControlGroup({'login': new Control(null)});
 
         var parent = new NgFormModel([], []);
-        parent.form = new ControlGroup({"group": formModel});
+        parent.form = new ControlGroup({'group': formModel});
         controlGroupDir = new NgControlGroup(parent, [], []);
-        controlGroupDir.name = "group";
+        controlGroupDir.name = 'group';
       });
 
-      it("should reexport control properties", () => {
+      it('should reexport control properties', () => {
         expect(controlGroupDir.control).toBe(formModel);
         expect(controlGroupDir.value).toBe(formModel.value);
         expect(controlGroupDir.valid).toBe(formModel.valid);
@@ -390,10 +363,10 @@ export function main() {
       });
     });
 
-    describe("NgFormControl", () => {
-      var controlDir;
-      var control;
-      var checkProperties = function(control) {
+    describe('NgFormControl', () => {
+      var controlDir: any /** TODO #9100 */;
+      var control: any /** TODO #9100 */;
+      var checkProperties = function(control: any /** TODO #9100 */) {
         expect(controlDir.control).toBe(control);
         expect(controlDir.value).toBe(control.value);
         expect(controlDir.valid).toBe(control.valid);
@@ -412,36 +385,36 @@ export function main() {
         controlDir.form = control;
       });
 
-      it("should reexport control properties", () => { checkProperties(control); });
+      it('should reexport control properties', () => { checkProperties(control); });
 
-      it("should reexport new control properties", () => {
+      it('should reexport new control properties', () => {
         var newControl = new Control(null);
         controlDir.form = newControl;
-        controlDir.ngOnChanges({"form": new SimpleChange(control, newControl)});
+        controlDir.ngOnChanges({'form': new SimpleChange(control, newControl)});
 
         checkProperties(newControl);
       });
 
-      it("should set up validator", () => {
+      it('should set up validator', () => {
         expect(control.valid).toBe(true);
 
         // this will add the required validator and recalculate the validity
-        controlDir.ngOnChanges({"form": new SimpleChange(null, control)});
+        controlDir.ngOnChanges({'form': new SimpleChange(null, control)});
 
         expect(control.valid).toBe(false);
       });
     });
 
-    describe("NgModel", () => {
-      var ngModel;
+    describe('NgModel', () => {
+      var ngModel: any /** TODO #9100 */;
 
       beforeEach(() => {
         ngModel =
-            new NgModel([Validators.required], [asyncValidator("expected")], [defaultAccessor]);
+            new NgModel([Validators.required], [asyncValidator('expected')], [defaultAccessor]);
         ngModel.valueAccessor = new DummyControlValueAccessor();
       });
 
-      it("should reexport control properties", () => {
+      it('should reexport control properties', () => {
         var control = ngModel.control;
         expect(ngModel.control).toBe(control);
         expect(ngModel.value).toBe(control.value);
@@ -453,34 +426,34 @@ export function main() {
         expect(ngModel.untouched).toBe(control.untouched);
       });
 
-      it("should set up validator", fakeAsync(() => {
+      it('should set up validator', fakeAsync(() => {
            // this will add the required validator and recalculate the validity
            ngModel.ngOnChanges({});
            tick();
 
-           expect(ngModel.control.errors).toEqual({"required": true});
+           expect(ngModel.control.errors).toEqual({'required': true});
 
-           ngModel.control.updateValue("someValue");
+           ngModel.control.updateValue('someValue');
            tick();
 
-           expect(ngModel.control.errors).toEqual({"async": true});
+           expect(ngModel.control.errors).toEqual({'async': true});
          }));
     });
 
-    describe("NgControlName", () => {
-      var formModel;
-      var controlNameDir;
+    describe('NgControlName', () => {
+      var formModel: any /** TODO #9100 */;
+      var controlNameDir: any /** TODO #9100 */;
 
       beforeEach(() => {
-        formModel = new Control("name");
+        formModel = new Control('name');
 
         var parent = new NgFormModel([], []);
-        parent.form = new ControlGroup({"name": formModel});
+        parent.form = new ControlGroup({'name': formModel});
         controlNameDir = new NgControlName(parent, [], [], [defaultAccessor]);
-        controlNameDir.name = "name";
+        controlNameDir.name = 'name';
       });
 
-      it("should reexport control properties", () => {
+      it('should reexport control properties', () => {
         expect(controlNameDir.control).toBe(formModel);
         expect(controlNameDir.value).toBe(formModel.value);
         expect(controlNameDir.valid).toBe(formModel.valid);

modules/@angular/common/test/forms-deprecated/form_builder_spec.ts

@@ -0,0 +1,63 @@
+import {Control, FormBuilder} from '@angular/common/src/forms-deprecated';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+
+import {PromiseWrapper} from '../../src/facade/promise';
+
+export function main() {
+  function syncValidator(_: any): any { return null; }
+  function asyncValidator(_: any) { return PromiseWrapper.resolve(null); }
+
+  describe('Form Builder', () => {
+    var b: any /** TODO #9100 */;
+
+    beforeEach(() => { b = new FormBuilder(); });
+
+    it('should create controls from a value', () => {
+      var g = b.group({'login': 'some value'});
+
+      expect(g.controls['login'].value).toEqual('some value');
+    });
+
+    it('should create controls from an array', () => {
+      var g = b.group(
+          {'login': ['some value'], 'password': ['some value', syncValidator, asyncValidator]});
+
+      expect(g.controls['login'].value).toEqual('some value');
+      expect(g.controls['password'].value).toEqual('some value');
+      expect(g.controls['password'].validator).toEqual(syncValidator);
+      expect(g.controls['password'].asyncValidator).toEqual(asyncValidator);
+    });
+
+    it('should use controls', () => {
+      var g = b.group({'login': b.control('some value', syncValidator, asyncValidator)});
+
+      expect(g.controls['login'].value).toEqual('some value');
+      expect(g.controls['login'].validator).toBe(syncValidator);
+      expect(g.controls['login'].asyncValidator).toBe(asyncValidator);
+    });
+
+    it('should create groups with optional controls', () => {
+      var g = b.group({'login': 'some value'}, {'optionals': {'login': false}});
+
+      expect(g.contains('login')).toEqual(false);
+    });
+
+    it('should create groups with a custom validator', () => {
+      var g = b.group(
+          {'login': 'some value'}, {'validator': syncValidator, 'asyncValidator': asyncValidator});
+
+      expect(g.validator).toBe(syncValidator);
+      expect(g.asyncValidator).toBe(asyncValidator);
+    });
+
+    it('should create control arrays', () => {
+      var c = b.control('three');
+      var a = b.array(
+          ['one', ['two', syncValidator], c, b.array(['four'])], syncValidator, asyncValidator);
+
+      expect(a.value).toEqual(['one', 'two', 'three', ['four']]);
+      expect(a.validator).toBe(syncValidator);
+      expect(a.asyncValidator).toBe(asyncValidator);
+    });
+  });
+}

modules/@angular/common/test/forms-deprecated/model_spec.ts

@@ -0,0 +1,827 @@
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach, inject,} from '@angular/core/testing/testing_internal';
+import {fakeAsync, flushMicrotasks, Log, tick} from '@angular/core/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {ControlGroup, Control, ControlArray, Validators} from '@angular/common/src/forms-deprecated';
+import {IS_DART, isPresent} from '../../src/facade/lang';
+import {PromiseWrapper} from '../../src/facade/promise';
+import {TimerWrapper, ObservableWrapper, EventEmitter} from '../../src/facade/async';
+
+export function main() {
+  function asyncValidator(expected: any /** TODO #9100 */, timeouts = /*@ts2dart_const*/ {}) {
+    return (c: any /** TODO #9100 */) => {
+      var completer = PromiseWrapper.completer();
+      var t = isPresent((timeouts as any /** TODO #9100 */)[c.value]) ?
+          (timeouts as any /** TODO #9100 */)[c.value] :
+          0;
+      var res = c.value != expected ? {'async': true} : null;
+
+      if (t == 0) {
+        completer.resolve(res);
+      } else {
+        TimerWrapper.setTimeout(() => { completer.resolve(res); }, t);
+      }
+
+      return completer.promise;
+    };
+  }
+
+  function asyncValidatorReturningObservable(c: any /** TODO #9100 */) {
+    var e = new EventEmitter();
+    PromiseWrapper.scheduleMicrotask(() => ObservableWrapper.callEmit(e, {'async': true}));
+    return e;
+  }
+
+  describe('Form Model', () => {
+    describe('Control', () => {
+      it('should default the value to null', () => {
+        var c = new Control();
+        expect(c.value).toBe(null);
+      });
+
+      describe('validator', () => {
+        it('should run validator with the initial value', () => {
+          var c = new Control('value', Validators.required);
+          expect(c.valid).toEqual(true);
+        });
+
+        it('should rerun the validator when the value changes', () => {
+          var c = new Control('value', Validators.required);
+          c.updateValue(null);
+          expect(c.valid).toEqual(false);
+        });
+
+        it('should return errors', () => {
+          var c = new Control(null, Validators.required);
+          expect(c.errors).toEqual({'required': true});
+        });
+      });
+
+      describe('asyncValidator', () => {
+        it('should run validator with the initial value', fakeAsync(() => {
+             var c = new Control('value', null, asyncValidator('expected'));
+             tick();
+
+             expect(c.valid).toEqual(false);
+             expect(c.errors).toEqual({'async': true});
+           }));
+
+        it('should support validators returning observables', fakeAsync(() => {
+             var c = new Control('value', null, asyncValidatorReturningObservable);
+             tick();
+
+             expect(c.valid).toEqual(false);
+             expect(c.errors).toEqual({'async': true});
+           }));
+
+        it('should rerun the validator when the value changes', fakeAsync(() => {
+             var c = new Control('value', null, asyncValidator('expected'));
+
+             c.updateValue('expected');
+             tick();
+
+             expect(c.valid).toEqual(true);
+           }));
+
+        it('should run the async validator only when the sync validator passes', fakeAsync(() => {
+             var c = new Control('', Validators.required, asyncValidator('expected'));
+             tick();
+
+             expect(c.errors).toEqual({'required': true});
+
+             c.updateValue('some value');
+             tick();
+
+             expect(c.errors).toEqual({'async': true});
+           }));
+
+        it('should mark the control as pending while running the async validation',
+           fakeAsync(() => {
+             var c = new Control('', null, asyncValidator('expected'));
+
+             expect(c.pending).toEqual(true);
+
+             tick();
+
+             expect(c.pending).toEqual(false);
+           }));
+
+        it('should only use the latest async validation run', fakeAsync(() => {
+             var c =
+                 new Control('', null, asyncValidator('expected', {'long': 200, 'expected': 100}));
+
+             c.updateValue('long');
+             c.updateValue('expected');
+
+             tick(300);
+
+             expect(c.valid).toEqual(true);
+           }));
+      });
+
+      describe('dirty', () => {
+        it('should be false after creating a control', () => {
+          var c = new Control('value');
+          expect(c.dirty).toEqual(false);
+        });
+
+        it('should be true after changing the value of the control', () => {
+          var c = new Control('value');
+          c.markAsDirty();
+          expect(c.dirty).toEqual(true);
+        });
+      });
+
+      describe('updateValue', () => {
+        var g: any /** TODO #9100 */, c: any /** TODO #9100 */;
+        beforeEach(() => {
+          c = new Control('oldValue');
+          g = new ControlGroup({'one': c});
+        });
+
+        it('should update the value of the control', () => {
+          c.updateValue('newValue');
+          expect(c.value).toEqual('newValue');
+        });
+
+        it('should invoke ngOnChanges if it is present', () => {
+          var ngOnChanges: any /** TODO #9100 */;
+          c.registerOnChange((v: any /** TODO #9100 */) => ngOnChanges = ['invoked', v]);
+
+          c.updateValue('newValue');
+
+          expect(ngOnChanges).toEqual(['invoked', 'newValue']);
+        });
+
+        it('should not invoke on change when explicitly specified', () => {
+          var onChange: any /** TODO #9100 */ = null;
+          c.registerOnChange((v: any /** TODO #9100 */) => onChange = ['invoked', v]);
+
+          c.updateValue('newValue', {emitModelToViewChange: false});
+
+          expect(onChange).toBeNull();
+        });
+
+        it('should update the parent', () => {
+          c.updateValue('newValue');
+          expect(g.value).toEqual({'one': 'newValue'});
+        });
+
+        it('should not update the parent when explicitly specified', () => {
+          c.updateValue('newValue', {onlySelf: true});
+          expect(g.value).toEqual({'one': 'oldValue'});
+        });
+
+        it('should fire an event', fakeAsync(() => {
+             ObservableWrapper.subscribe(
+                 c.valueChanges, (value) => { expect(value).toEqual('newValue'); });
+
+             c.updateValue('newValue');
+             tick();
+           }));
+
+        it('should not fire an event when explicitly specified', fakeAsync(() => {
+             ObservableWrapper.subscribe(c.valueChanges, (value) => { throw 'Should not happen'; });
+
+             c.updateValue('newValue', {emitEvent: false});
+
+             tick();
+           }));
+      });
+
+      describe('valueChanges & statusChanges', () => {
+        var c: any /** TODO #9100 */;
+
+        beforeEach(() => { c = new Control('old', Validators.required); });
+
+        it('should fire an event after the value has been updated',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             ObservableWrapper.subscribe(c.valueChanges, (value) => {
+               expect(c.value).toEqual('new');
+               expect(value).toEqual('new');
+               async.done();
+             });
+             c.updateValue('new');
+           }));
+
+        it('should fire an event after the status has been updated to invalid', fakeAsync(() => {
+             ObservableWrapper.subscribe(c.statusChanges, (status) => {
+               expect(c.status).toEqual('INVALID');
+               expect(status).toEqual('INVALID');
+             });
+
+             c.updateValue('');
+             tick();
+           }));
+
+        it('should fire an event after the status has been updated to pending', fakeAsync(() => {
+             var c = new Control('old', Validators.required, asyncValidator('expected'));
+
+             var log: any[] /** TODO #9100 */ = [];
+             ObservableWrapper.subscribe(c.valueChanges, (value) => log.push(`value: '${value}'`));
+             ObservableWrapper.subscribe(
+                 c.statusChanges, (status) => log.push(`status: '${status}'`));
+
+             c.updateValue('');
+             tick();
+
+             c.updateValue('nonEmpty');
+             tick();
+
+             c.updateValue('expected');
+             tick();
+
+             expect(log).toEqual([
+               '' +
+                   'value: \'\'',
+               'status: \'INVALID\'',
+               'value: \'nonEmpty\'',
+               'status: \'PENDING\'',
+               'status: \'INVALID\'',
+               'value: \'expected\'',
+               'status: \'PENDING\'',
+               'status: \'VALID\'',
+             ]);
+           }));
+
+        // TODO: remove the if statement after making observable delivery sync
+        if (!IS_DART) {
+          it('should update set errors and status before emitting an event',
+             inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+               c.valueChanges.subscribe((value: any /** TODO #9100 */) => {
+                 expect(c.valid).toEqual(false);
+                 expect(c.errors).toEqual({'required': true});
+                 async.done();
+               });
+               c.updateValue('');
+             }));
+        }
+
+        it('should return a cold observable',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             c.updateValue('will be ignored');
+             ObservableWrapper.subscribe(c.valueChanges, (value) => {
+               expect(value).toEqual('new');
+               async.done();
+             });
+             c.updateValue('new');
+           }));
+      });
+
+      describe('setErrors', () => {
+        it('should set errors on a control', () => {
+          var c = new Control('someValue');
+
+          c.setErrors({'someError': true});
+
+          expect(c.valid).toEqual(false);
+          expect(c.errors).toEqual({'someError': true});
+        });
+
+        it('should reset the errors and validity when the value changes', () => {
+          var c = new Control('someValue', Validators.required);
+
+          c.setErrors({'someError': true});
+          c.updateValue('');
+
+          expect(c.errors).toEqual({'required': true});
+        });
+
+        it('should update the parent group\'s validity', () => {
+          var c = new Control('someValue');
+          var g = new ControlGroup({'one': c});
+
+          expect(g.valid).toEqual(true);
+
+          c.setErrors({'someError': true});
+
+          expect(g.valid).toEqual(false);
+        });
+
+        it('should not reset parent\'s errors', () => {
+          var c = new Control('someValue');
+          var g = new ControlGroup({'one': c});
+
+          g.setErrors({'someGroupError': true});
+          c.setErrors({'someError': true});
+
+          expect(g.errors).toEqual({'someGroupError': true});
+        });
+
+        it('should reset errors when updating a value', () => {
+          var c = new Control('oldValue');
+          var g = new ControlGroup({'one': c});
+
+          g.setErrors({'someGroupError': true});
+          c.setErrors({'someError': true});
+
+          c.updateValue('newValue');
+
+          expect(c.errors).toEqual(null);
+          expect(g.errors).toEqual(null);
+        });
+      });
+    });
+
+    describe('ControlGroup', () => {
+      describe('value', () => {
+        it('should be the reduced value of the child controls', () => {
+          var g = new ControlGroup({'one': new Control('111'), 'two': new Control('222')});
+          expect(g.value).toEqual({'one': '111', 'two': '222'});
+        });
+
+        it('should be empty when there are no child controls', () => {
+          var g = new ControlGroup({});
+          expect(g.value).toEqual({});
+        });
+
+        it('should support nested groups', () => {
+          var g = new ControlGroup(
+              {'one': new Control('111'), 'nested': new ControlGroup({'two': new Control('222')})});
+          expect(g.value).toEqual({'one': '111', 'nested': {'two': '222'}});
+
+          (<Control>(g.controls['nested'].find('two'))).updateValue('333');
+
+          expect(g.value).toEqual({'one': '111', 'nested': {'two': '333'}});
+        });
+      });
+
+      describe('adding and removing controls', () => {
+        it('should update value and validity when control is added', () => {
+          var g = new ControlGroup({'one': new Control('1')});
+          expect(g.value).toEqual({'one': '1'});
+          expect(g.valid).toBe(true);
+
+          g.addControl('two', new Control('2', Validators.minLength(10)));
+
+          expect(g.value).toEqual({'one': '1', 'two': '2'});
+          expect(g.valid).toBe(false);
+        });
+
+        it('should update value and validity when control is removed', () => {
+          var g = new ControlGroup(
+              {'one': new Control('1'), 'two': new Control('2', Validators.minLength(10))});
+          expect(g.value).toEqual({'one': '1', 'two': '2'});
+          expect(g.valid).toBe(false);
+
+          g.removeControl('two');
+
+          expect(g.value).toEqual({'one': '1'});
+          expect(g.valid).toBe(true);
+        });
+      });
+
+      describe('errors', () => {
+        it('should run the validator when the value changes', () => {
+          var simpleValidator = (c: any /** TODO #9100 */) =>
+              c.controls['one'].value != 'correct' ? {'broken': true} : null;
+
+          var c = new Control(null);
+          var g = new ControlGroup({'one': c}, null, simpleValidator);
+
+          c.updateValue('correct');
+
+          expect(g.valid).toEqual(true);
+          expect(g.errors).toEqual(null);
+
+          c.updateValue('incorrect');
+
+          expect(g.valid).toEqual(false);
+          expect(g.errors).toEqual({'broken': true});
+        });
+      });
+
+      describe('dirty', () => {
+        var c: any /** TODO #9100 */, g: any /** TODO #9100 */;
+
+        beforeEach(() => {
+          c = new Control('value');
+          g = new ControlGroup({'one': c});
+        });
+
+        it('should be false after creating a control', () => { expect(g.dirty).toEqual(false); });
+
+        it('should be false after changing the value of the control', () => {
+          c.markAsDirty();
+
+          expect(g.dirty).toEqual(true);
+        });
+      });
+
+      describe('optional components', () => {
+        describe('contains', () => {
+          var group: any /** TODO #9100 */;
+
+          beforeEach(() => {
+            group = new ControlGroup(
+                {
+                  'required': new Control('requiredValue'),
+                  'optional': new Control('optionalValue')
+                },
+                {'optional': false});
+          });
+
+          // rename contains into has
+          it('should return false when the component is not included',
+             () => { expect(group.contains('optional')).toEqual(false); })
+
+          it('should return false when there is no component with the given name',
+             () => { expect(group.contains('something else')).toEqual(false); });
+
+          it('should return true when the component is included', () => {
+            expect(group.contains('required')).toEqual(true);
+
+            group.include('optional');
+
+            expect(group.contains('optional')).toEqual(true);
+          });
+        });
+
+        it('should not include an inactive component into the group value', () => {
+          var group = new ControlGroup(
+              {'required': new Control('requiredValue'), 'optional': new Control('optionalValue')},
+              {'optional': false});
+
+          expect(group.value).toEqual({'required': 'requiredValue'});
+
+          group.include('optional');
+
+          expect(group.value).toEqual({'required': 'requiredValue', 'optional': 'optionalValue'});
+        });
+
+        it('should not run Validators on an inactive component', () => {
+          var group = new ControlGroup(
+              {
+                'required': new Control('requiredValue', Validators.required),
+                'optional': new Control('', Validators.required)
+              },
+              {'optional': false});
+
+          expect(group.valid).toEqual(true);
+
+          group.include('optional');
+
+          expect(group.valid).toEqual(false);
+        });
+      });
+
+      describe('valueChanges', () => {
+        var g: any /** TODO #9100 */, c1: any /** TODO #9100 */, c2: any /** TODO #9100 */;
+
+        beforeEach(() => {
+          c1 = new Control('old1');
+          c2 = new Control('old2');
+          g = new ControlGroup({'one': c1, 'two': c2}, {'two': true});
+        });
+
+        it('should fire an event after the value has been updated',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             ObservableWrapper.subscribe(g.valueChanges, (value) => {
+               expect(g.value).toEqual({'one': 'new1', 'two': 'old2'});
+               expect(value).toEqual({'one': 'new1', 'two': 'old2'});
+               async.done();
+             });
+             c1.updateValue('new1');
+           }));
+
+        it('should fire an event after the control\'s observable fired an event',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             var controlCallbackIsCalled = false;
+
+             ObservableWrapper.subscribe(
+                 c1.valueChanges, (value) => { controlCallbackIsCalled = true; });
+
+             ObservableWrapper.subscribe(g.valueChanges, (value) => {
+               expect(controlCallbackIsCalled).toBe(true);
+               async.done();
+             });
+
+             c1.updateValue('new1');
+           }));
+
+        it('should fire an event when a control is excluded',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             ObservableWrapper.subscribe(g.valueChanges, (value) => {
+               expect(value).toEqual({'one': 'old1'});
+               async.done();
+             });
+
+             g.exclude('two');
+           }));
+
+        it('should fire an event when a control is included',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             g.exclude('two');
+
+             ObservableWrapper.subscribe(g.valueChanges, (value) => {
+               expect(value).toEqual({'one': 'old1', 'two': 'old2'});
+               async.done();
+             });
+
+             g.include('two');
+           }));
+
+        it('should fire an event every time a control is updated',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             var loggedValues: any[] /** TODO #9100 */ = [];
+
+             ObservableWrapper.subscribe(g.valueChanges, (value) => {
+               loggedValues.push(value);
+
+               if (loggedValues.length == 2) {
+                 expect(loggedValues).toEqual([
+                   {'one': 'new1', 'two': 'old2'}, {'one': 'new1', 'two': 'new2'}
+                 ]);
+                 async.done();
+               }
+             });
+
+             c1.updateValue('new1');
+             c2.updateValue('new2');
+           }));
+
+        xit('should not fire an event when an excluded control is updated',
+            inject(
+                [AsyncTestCompleter], (async: AsyncTestCompleter) => {
+                                          // hard to test without hacking zones
+                                      }));
+      });
+
+      describe('getError', () => {
+        it('should return the error when it is present', () => {
+          var c = new Control('', Validators.required);
+          var g = new ControlGroup({'one': c});
+          expect(c.getError('required')).toEqual(true);
+          expect(g.getError('required', ['one'])).toEqual(true);
+        });
+
+        it('should return null otherwise', () => {
+          var c = new Control('not empty', Validators.required);
+          var g = new ControlGroup({'one': c});
+          expect(c.getError('invalid')).toEqual(null);
+          expect(g.getError('required', ['one'])).toEqual(null);
+          expect(g.getError('required', ['invalid'])).toEqual(null);
+        });
+      });
+
+      describe('asyncValidator', () => {
+        it('should run the async validator', fakeAsync(() => {
+             var c = new Control('value');
+             var g = new ControlGroup({'one': c}, null, null, asyncValidator('expected'));
+
+             expect(g.pending).toEqual(true);
+
+             tick(1);
+
+             expect(g.errors).toEqual({'async': true});
+             expect(g.pending).toEqual(false);
+           }));
+
+        it('should set the parent group\'s status to pending', fakeAsync(() => {
+             var c = new Control('value', null, asyncValidator('expected'));
+             var g = new ControlGroup({'one': c});
+
+             expect(g.pending).toEqual(true);
+
+             tick(1);
+
+             expect(g.pending).toEqual(false);
+           }));
+
+        it('should run the parent group\'s async validator when children are pending',
+           fakeAsync(() => {
+             var c = new Control('value', null, asyncValidator('expected'));
+             var g = new ControlGroup({'one': c}, null, null, asyncValidator('expected'));
+
+             tick(1);
+
+             expect(g.errors).toEqual({'async': true});
+             expect(g.find(['one']).errors).toEqual({'async': true});
+           }));
+      })
+    });
+
+    describe('ControlArray', () => {
+      describe('adding/removing', () => {
+        var a: ControlArray;
+        var c1: any /** TODO #9100 */, c2: any /** TODO #9100 */, c3: any /** TODO #9100 */;
+
+        beforeEach(() => {
+          a = new ControlArray([]);
+          c1 = new Control(1);
+          c2 = new Control(2);
+          c3 = new Control(3);
+        });
+
+        it('should support pushing', () => {
+          a.push(c1);
+          expect(a.length).toEqual(1);
+          expect(a.controls).toEqual([c1]);
+        });
+
+        it('should support removing', () => {
+          a.push(c1);
+          a.push(c2);
+          a.push(c3);
+
+          a.removeAt(1);
+
+          expect(a.controls).toEqual([c1, c3]);
+        });
+
+        it('should support inserting', () => {
+          a.push(c1);
+          a.push(c3);
+
+          a.insert(1, c2);
+
+          expect(a.controls).toEqual([c1, c2, c3]);
+        });
+      });
+
+      describe('value', () => {
+        it('should be the reduced value of the child controls', () => {
+          var a = new ControlArray([new Control(1), new Control(2)]);
+          expect(a.value).toEqual([1, 2]);
+        });
+
+        it('should be an empty array when there are no child controls', () => {
+          var a = new ControlArray([]);
+          expect(a.value).toEqual([]);
+        });
+      });
+
+      describe('errors', () => {
+        it('should run the validator when the value changes', () => {
+          var simpleValidator = (c: any /** TODO #9100 */) =>
+              c.controls[0].value != 'correct' ? {'broken': true} : null;
+
+          var c = new Control(null);
+          var g = new ControlArray([c], simpleValidator);
+
+          c.updateValue('correct');
+
+          expect(g.valid).toEqual(true);
+          expect(g.errors).toEqual(null);
+
+          c.updateValue('incorrect');
+
+          expect(g.valid).toEqual(false);
+          expect(g.errors).toEqual({'broken': true});
+        });
+      });
+
+
+      describe('dirty', () => {
+        var c: Control;
+        var a: ControlArray;
+
+        beforeEach(() => {
+          c = new Control('value');
+          a = new ControlArray([c]);
+        });
+
+        it('should be false after creating a control', () => { expect(a.dirty).toEqual(false); });
+
+        it('should be false after changing the value of the control', () => {
+          c.markAsDirty();
+
+          expect(a.dirty).toEqual(true);
+        });
+      });
+
+      describe('pending', () => {
+        var c: Control;
+        var a: ControlArray;
+
+        beforeEach(() => {
+          c = new Control('value');
+          a = new ControlArray([c]);
+        });
+
+        it('should be false after creating a control', () => {
+          expect(c.pending).toEqual(false);
+          expect(a.pending).toEqual(false);
+        });
+
+        it('should be true after changing the value of the control', () => {
+          c.markAsPending();
+
+          expect(c.pending).toEqual(true);
+          expect(a.pending).toEqual(true);
+        });
+
+        it('should not update the parent when onlySelf = true', () => {
+          c.markAsPending({onlySelf: true});
+
+          expect(c.pending).toEqual(true);
+          expect(a.pending).toEqual(false);
+        });
+      });
+
+      describe('valueChanges', () => {
+        var a: ControlArray;
+        var c1: any /** TODO #9100 */, c2: any /** TODO #9100 */;
+
+        beforeEach(() => {
+          c1 = new Control('old1');
+          c2 = new Control('old2');
+          a = new ControlArray([c1, c2]);
+        });
+
+        it('should fire an event after the value has been updated',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             ObservableWrapper.subscribe(a.valueChanges, (value) => {
+               expect(a.value).toEqual(['new1', 'old2']);
+               expect(value).toEqual(['new1', 'old2']);
+               async.done();
+             });
+             c1.updateValue('new1');
+           }));
+
+        it('should fire an event after the control\'s observable fired an event',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             var controlCallbackIsCalled = false;
+
+             ObservableWrapper.subscribe(
+                 c1.valueChanges, (value) => { controlCallbackIsCalled = true; });
+
+             ObservableWrapper.subscribe(a.valueChanges, (value) => {
+               expect(controlCallbackIsCalled).toBe(true);
+               async.done();
+             });
+
+             c1.updateValue('new1');
+           }));
+
+        it('should fire an event when a control is removed',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             ObservableWrapper.subscribe(a.valueChanges, (value) => {
+               expect(value).toEqual(['old1']);
+               async.done();
+             });
+
+             a.removeAt(1);
+           }));
+
+        it('should fire an event when a control is added',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+             a.removeAt(1);
+
+             ObservableWrapper.subscribe(a.valueChanges, (value) => {
+               expect(value).toEqual(['old1', 'old2']);
+               async.done();
+             });
+
+             a.push(c2);
+           }));
+      });
+
+      describe('find', () => {
+        it('should return null when path is null', () => {
+          var g = new ControlGroup({});
+          expect(g.find(null)).toEqual(null);
+        });
+
+        it('should return null when path is empty', () => {
+          var g = new ControlGroup({});
+          expect(g.find([])).toEqual(null);
+        });
+
+        it('should return null when path is invalid', () => {
+          var g = new ControlGroup({});
+          expect(g.find(['one', 'two'])).toEqual(null);
+        });
+
+        it('should return a child of a control group', () => {
+          var g = new ControlGroup(
+              {'one': new Control('111'), 'nested': new ControlGroup({'two': new Control('222')})});
+
+          expect(g.find(['nested', 'two']).value).toEqual('222');
+          expect(g.find(['one']).value).toEqual('111');
+          expect(g.find('nested/two').value).toEqual('222');
+          expect(g.find('one').value).toEqual('111');
+        });
+
+        it('should return an element of an array', () => {
+          var g = new ControlGroup({'array': new ControlArray([new Control('111')])});
+
+          expect(g.find(['array', 0]).value).toEqual('111');
+        });
+      });
+
+      describe('asyncValidator', () => {
+        it('should run the async validator', fakeAsync(() => {
+             var c = new Control('value');
+             var g = new ControlArray([c], null, asyncValidator('expected'));
+
+             expect(g.pending).toEqual(true);
+
+             tick(1);
+
+             expect(g.errors).toEqual({'async': true});
+             expect(g.pending).toEqual(false);
+           }));
+      })
+    });
+  });
+}

modules/@angular/common/test/forms-deprecated/validators_spec.ts

@@ -0,0 +1,164 @@
+import {AbstractControl, Control, ControlArray, ControlGroup, Validators} from '@angular/common/src/forms-deprecated';
+import {Log, fakeAsync, flushMicrotasks, tick} from '@angular/core/testing';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+
+import {EventEmitter, ObservableWrapper, TimerWrapper} from '../../src/facade/async';
+import {PromiseWrapper} from '../../src/facade/promise';
+
+export function main() {
+  function validator(key: string, error: any) {
+    return function(c: AbstractControl) {
+      var r = {};
+      (r as any /** TODO #9100 */)[key] = error;
+      return r;
+    }
+  }
+
+  describe('Validators', () => {
+    describe('required', () => {
+      it('should error on an empty string',
+         () => { expect(Validators.required(new Control(''))).toEqual({'required': true}); });
+
+      it('should error on null',
+         () => { expect(Validators.required(new Control(null))).toEqual({'required': true}); });
+
+      it('should not error on a non-empty string',
+         () => { expect(Validators.required(new Control('not empty'))).toEqual(null); });
+
+      it('should accept zero as valid',
+         () => { expect(Validators.required(new Control(0))).toEqual(null); });
+    });
+
+    describe('minLength', () => {
+      it('should not error on an empty string',
+         () => { expect(Validators.minLength(2)(new Control(''))).toEqual(null); });
+
+      it('should not error on null',
+         () => { expect(Validators.minLength(2)(new Control(null))).toEqual(null); });
+
+      it('should not error on valid strings',
+         () => { expect(Validators.minLength(2)(new Control('aa'))).toEqual(null); });
+
+      it('should error on short strings', () => {
+        expect(Validators.minLength(2)(new Control('a'))).toEqual({
+          'minlength': {'requiredLength': 2, 'actualLength': 1}
+        });
+      });
+    });
+
+    describe('maxLength', () => {
+      it('should not error on an empty string',
+         () => { expect(Validators.maxLength(2)(new Control(''))).toEqual(null); });
+
+      it('should not error on null',
+         () => { expect(Validators.maxLength(2)(new Control(null))).toEqual(null); });
+
+      it('should not error on valid strings',
+         () => { expect(Validators.maxLength(2)(new Control('aa'))).toEqual(null); });
+
+      it('should error on long strings', () => {
+        expect(Validators.maxLength(2)(new Control('aaa'))).toEqual({
+          'maxlength': {'requiredLength': 2, 'actualLength': 3}
+        });
+      });
+    });
+
+    describe('pattern', () => {
+      it('should not error on an empty string',
+         () => { expect(Validators.pattern('[a-zA-Z ]*')(new Control(''))).toEqual(null); });
+
+      it('should not error on null',
+         () => { expect(Validators.pattern('[a-zA-Z ]*')(new Control(null))).toEqual(null); });
+
+      it('should not error on valid strings',
+         () => { expect(Validators.pattern('[a-zA-Z ]*')(new Control('aaAA'))).toEqual(null); });
+
+      it('should error on failure to match string', () => {
+        expect(Validators.pattern('[a-zA-Z ]*')(new Control('aaa0'))).toEqual({
+          'pattern': {'requiredPattern': '^[a-zA-Z ]*$', 'actualValue': 'aaa0'}
+        });
+      });
+    });
+
+    describe('compose', () => {
+      it('should return null when given null',
+         () => { expect(Validators.compose(null)).toBe(null); });
+
+      it('should collect errors from all the validators', () => {
+        var c = Validators.compose([validator('a', true), validator('b', true)]);
+        expect(c(new Control(''))).toEqual({'a': true, 'b': true});
+      });
+
+      it('should run validators left to right', () => {
+        var c = Validators.compose([validator('a', 1), validator('a', 2)]);
+        expect(c(new Control(''))).toEqual({'a': 2});
+      });
+
+      it('should return null when no errors', () => {
+        var c = Validators.compose([Validators.nullValidator, Validators.nullValidator]);
+        expect(c(new Control(''))).toEqual(null);
+      });
+
+      it('should ignore nulls', () => {
+        var c = Validators.compose([null, Validators.required]);
+        expect(c(new Control(''))).toEqual({'required': true});
+      });
+    });
+
+    describe('composeAsync', () => {
+      function asyncValidator(expected: any /** TODO #9100 */, response: any /** TODO #9100 */) {
+        return (c: any /** TODO #9100 */) => {
+          var emitter = new EventEmitter();
+          var res = c.value != expected ? response : null;
+
+          PromiseWrapper.scheduleMicrotask(() => {
+            ObservableWrapper.callEmit(emitter, res);
+            // this is required because of a bug in ObservableWrapper
+            // where callComplete can fire before callEmit
+            // remove this one the bug is fixed
+            TimerWrapper.setTimeout(() => { ObservableWrapper.callComplete(emitter); }, 0);
+          });
+          return emitter;
+        };
+      }
+
+      it('should return null when given null',
+         () => { expect(Validators.composeAsync(null)).toEqual(null); });
+
+      it('should collect errors from all the validators', fakeAsync(() => {
+           var c = Validators.composeAsync([
+             asyncValidator('expected', {'one': true}), asyncValidator('expected', {'two': true})
+           ]);
+
+           var value: any /** TODO #9100 */ = null;
+           (<Promise<any>>c(new Control('invalid'))).then(v => value = v);
+
+           tick(1);
+
+           expect(value).toEqual({'one': true, 'two': true});
+         }));
+
+      it('should return null when no errors', fakeAsync(() => {
+           var c = Validators.composeAsync([asyncValidator('expected', {'one': true})]);
+
+           var value: any /** TODO #9100 */ = null;
+           (<Promise<any>>c(new Control('expected'))).then(v => value = v);
+
+           tick(1);
+
+           expect(value).toEqual(null);
+         }));
+
+      it('should ignore nulls', fakeAsync(() => {
+           var c = Validators.composeAsync([asyncValidator('expected', {'one': true}), null]);
+
+           var value: any /** TODO #9100 */ = null;
+           (<Promise<any>>c(new Control('invalid'))).then(v => value = v);
+
+           tick(1);
+
+           expect(value).toEqual({'one': true});
+         }));
+    });
+  });
+}

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

@@ -1,38 +1,22 @@
-import {
-  ddescribe,
-  describe,
-  it,
-  iit,
-  xit,
-  expect,
-  beforeEach,
-  afterEach,
-  AsyncTestCompleter,
-  inject,
-  browserDetection
-} from 'angular2/testing_internal';
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach, inject,} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
 import {SpyChangeDetectorRef} from '../spies';
-
-import {isBlank} from 'angular2/src/facade/lang';
-import {AsyncPipe} from 'angular2/common';
-import {WrappedValue} from 'angular2/core';
-import {
-  EventEmitter,
-  ObservableWrapper,
-  PromiseWrapper,
-  TimerWrapper
-} from 'angular2/src/facade/async';
-import {DOM} from 'angular2/src/platform/dom/dom_adapter';
-import {PromiseCompleter} from 'angular2/src/facade/promise';
+import {isBlank} from '../../src/facade/lang';
+import {AsyncPipe} from '@angular/common';
+import {WrappedValue} from '@angular/core';
+import {EventEmitter, ObservableWrapper, PromiseWrapper, TimerWrapper} from '../../src/facade/async';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {PromiseCompleter} from '../../src/facade/promise';
+import {browserDetection} from '@angular/platform-browser/testing';
 
 export function main() {
-  describe("AsyncPipe", () => {
+  describe('AsyncPipe', () => {
 
     describe('Observable', () => {
-      var emitter;
-      var pipe;
-      var ref;
-      var message = new Object();
+      var emitter: EventEmitter<any>;
+      var pipe: AsyncPipe;
+      var ref: any;
+      var message = {};
 
       beforeEach(() => {
         emitter = new EventEmitter();
@@ -40,12 +24,12 @@ export function main() {
         pipe = new AsyncPipe(ref);
       });
 
-      describe("transform", () => {
-        it("should return null when subscribing to an observable",
+      describe('transform', () => {
+        it('should return null when subscribing to an observable',
            () => { expect(pipe.transform(emitter)).toBe(null); });
 
-        it("should return the latest available value wrapped",
-           inject([AsyncTestCompleter], (async) => {
+        it('should return the latest available value wrapped',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(emitter);
 
              ObservableWrapper.callEmit(emitter, message);
@@ -57,8 +41,8 @@ export function main() {
            }));
 
 
-        it("should return same value when nothing has changed since the last call",
-           inject([AsyncTestCompleter], (async) => {
+        it('should return same value when nothing has changed since the last call',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(emitter);
              ObservableWrapper.callEmit(emitter, message);
 
@@ -69,8 +53,8 @@ export function main() {
              }, 0)
            }));
 
-        it("should dispose of the existing subscription when subscribing to a new observable",
-           inject([AsyncTestCompleter], (async) => {
+        it('should dispose of the existing subscription when subscribing to a new observable',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(emitter);
 
              var newEmitter = new EventEmitter();
@@ -85,8 +69,8 @@ export function main() {
              }, 0)
            }));
 
-        it("should request a change detection check upon receiving a new value",
-           inject([AsyncTestCompleter], (async) => {
+        it('should request a change detection check upon receiving a new value',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(emitter);
              ObservableWrapper.callEmit(emitter, message);
 
@@ -97,11 +81,12 @@ export function main() {
            }));
       });
 
-      describe("ngOnDestroy", () => {
-        it("should do nothing when no subscription",
+      describe('ngOnDestroy', () => {
+        it('should do nothing when no subscription',
            () => { expect(() => pipe.ngOnDestroy()).not.toThrow(); });
 
-        it("should dispose of the existing subscription", inject([AsyncTestCompleter], (async) => {
+        it('should dispose of the existing subscription',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(emitter);
              pipe.ngOnDestroy();
 
@@ -115,13 +100,13 @@ export function main() {
       });
     });
 
-    describe("Promise", () => {
+    describe('Promise', () => {
       var message = new Object();
       var pipe: AsyncPipe;
       var completer: PromiseCompleter<any>;
       var ref: SpyChangeDetectorRef;
       // adds longer timers for passing tests in IE
-      var timer = (!isBlank(DOM) && browserDetection.isIE) ? 50 : 10;
+      var timer = (!isBlank(getDOM()) && browserDetection.isIE) ? 50 : 10;
 
       beforeEach(() => {
         completer = PromiseWrapper.completer();
@@ -129,11 +114,12 @@ export function main() {
         pipe = new AsyncPipe(<any>ref);
       });
 
-      describe("transform", () => {
-        it("should return null when subscribing to a promise",
+      describe('transform', () => {
+        it('should return null when subscribing to a promise',
            () => { expect(pipe.transform(completer.promise)).toBe(null); });
 
-        it("should return the latest available value", inject([AsyncTestCompleter], (async) => {
+        it('should return the latest available value',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(completer.promise);
 
              completer.resolve(message);
@@ -144,8 +130,8 @@ export function main() {
              }, timer)
            }));
 
-        it("should return unwrapped value when nothing has changed since the last call",
-           inject([AsyncTestCompleter], (async) => {
+        it('should return unwrapped value when nothing has changed since the last call',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(completer.promise);
              completer.resolve(message);
 
@@ -156,8 +142,8 @@ export function main() {
              }, timer)
            }));
 
-        it("should dispose of the existing subscription when subscribing to a new promise",
-           inject([AsyncTestCompleter], (async) => {
+        it('should dispose of the existing subscription when subscribing to a new promise',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              pipe.transform(completer.promise);
 
              var newCompleter = PromiseWrapper.completer();
@@ -172,8 +158,8 @@ export function main() {
              }, timer)
            }));
 
-        it("should request a change detection check upon receiving a new value",
-           inject([AsyncTestCompleter], (async) => {
+        it('should request a change detection check upon receiving a new value',
+           inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
              var markForCheck = ref.spy('markForCheck');
              pipe.transform(completer.promise);
              completer.resolve(message);
@@ -184,11 +170,12 @@ export function main() {
              }, timer)
            }));
 
-        describe("ngOnDestroy", () => {
-          it("should do nothing when no source",
+        describe('ngOnDestroy', () => {
+          it('should do nothing when no source',
              () => { expect(() => pipe.ngOnDestroy()).not.toThrow(); });
 
-          it("should dispose of the existing source", inject([AsyncTestCompleter], (async) => {
+          it('should dispose of the existing source',
+             inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
                pipe.transform(completer.promise);
                expect(pipe.transform(completer.promise)).toBe(null);
                completer.resolve(message)
@@ -208,14 +195,14 @@ export function main() {
     describe('null', () => {
       it('should return null when given null', () => {
         var pipe = new AsyncPipe(null);
-        expect(pipe.transform(null, [])).toEqual(null);
+        expect(pipe.transform(null)).toEqual(null);
       });
     });
 
     describe('other types', () => {
       it('should throw when given an invalid object', () => {
         var pipe = new AsyncPipe(null);
-        expect(() => pipe.transform(<any>"some bogus object", [])).toThrowError();
+        expect(() => pipe.transform(<any>'some bogus object')).toThrowError();
       });
     });
   });

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

@@ -0,0 +1,89 @@
+import {DatePipe} from '@angular/common';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+import {browserDetection} from '@angular/platform-browser/testing';
+
+import {DateWrapper} from '../../src/facade/lang';
+
+export function main() {
+  describe('DatePipe', () => {
+    var date: Date;
+    var pipe: DatePipe;
+
+    beforeEach(() => {
+      date = DateWrapper.create(2015, 6, 15, 21, 3, 1);
+      pipe = new DatePipe();
+    });
+
+    it('should be marked as pure',
+       () => { expect(new PipeResolver().resolve(DatePipe).pure).toEqual(true); });
+
+    // TODO(mlaval): enable tests when Intl API is no longer used, see
+    // https://github.com/angular/angular/issues/3333
+    // Have to restrict to Chrome as IE uses a different formatting
+    if (browserDetection.supportsIntlApi && browserDetection.isChromeDesktop) {
+      describe('supports', () => {
+        it('should support date', () => { expect(() => pipe.transform(date)).not.toThrow(); });
+        it('should support int', () => { expect(() => pipe.transform(123456789)).not.toThrow(); });
+        it('should support numeric strings',
+           () => { expect(() => pipe.transform('123456789')).not.toThrow(); });
+
+        it('should support ISO string',
+           () => { expect(() => pipe.transform('2015-06-15T21:43:11Z')).not.toThrow(); });
+
+        it('should not support other objects', () => {
+          expect(() => pipe.transform({})).toThrow();
+          expect(() => pipe.transform('')).toThrow();
+        });
+      });
+
+      describe('transform', () => {
+        it('should format each component correctly', () => {
+          expect(pipe.transform(date, 'y')).toEqual('2015');
+          expect(pipe.transform(date, 'yy')).toEqual('15');
+          expect(pipe.transform(date, 'M')).toEqual('6');
+          expect(pipe.transform(date, 'MM')).toEqual('06');
+          expect(pipe.transform(date, 'MMM')).toEqual('Jun');
+          expect(pipe.transform(date, 'MMMM')).toEqual('June');
+          expect(pipe.transform(date, 'd')).toEqual('15');
+          expect(pipe.transform(date, 'E')).toEqual('Mon');
+          expect(pipe.transform(date, 'EEEE')).toEqual('Monday');
+          expect(pipe.transform(date, 'H')).toEqual('21');
+          expect(pipe.transform(date, 'j')).toEqual('9 PM');
+          expect(pipe.transform(date, 'm')).toEqual('3');
+          expect(pipe.transform(date, 's')).toEqual('1');
+          expect(pipe.transform(date, 'mm')).toEqual('03');
+          expect(pipe.transform(date, 'ss')).toEqual('01');
+        });
+
+        it('should format common multi component patterns', () => {
+          expect(pipe.transform(date, 'E, M/d/y')).toEqual('Mon, 6/15/2015');
+          expect(pipe.transform(date, 'E, M/d')).toEqual('Mon, 6/15');
+          expect(pipe.transform(date, 'MMM d')).toEqual('Jun 15');
+          expect(pipe.transform(date, 'dd/MM/yyyy')).toEqual('15/06/2015');
+          expect(pipe.transform(date, 'MM/dd/yyyy')).toEqual('06/15/2015');
+          expect(pipe.transform(date, 'yMEd')).toEqual('20156Mon15');
+          expect(pipe.transform(date, 'MEd')).toEqual('6Mon15');
+          expect(pipe.transform(date, 'MMMd')).toEqual('Jun15');
+          expect(pipe.transform(date, 'yMMMMEEEEd')).toEqual('Monday, June 15, 2015');
+          expect(pipe.transform(date, 'jms')).toEqual('9:03:01 PM');
+          expect(pipe.transform(date, 'ms')).toEqual('31');
+          expect(pipe.transform(date, 'jm')).toEqual('9:03 PM');
+        });
+
+        it('should format with pattern aliases', () => {
+          expect(pipe.transform(date, 'medium')).toEqual('Jun 15, 2015, 9:03:01 PM');
+          expect(pipe.transform(date, 'short')).toEqual('6/15/2015, 9:03 PM');
+          expect(pipe.transform(date, 'dd/MM/yyyy')).toEqual('15/06/2015');
+          expect(pipe.transform(date, 'MM/dd/yyyy')).toEqual('06/15/2015');
+          expect(pipe.transform(date, 'fullDate')).toEqual('Monday, June 15, 2015');
+          expect(pipe.transform(date, 'longDate')).toEqual('June 15, 2015');
+          expect(pipe.transform(date, 'mediumDate')).toEqual('Jun 15, 2015');
+          expect(pipe.transform(date, 'shortDate')).toEqual('6/15/2015');
+          expect(pipe.transform(date, 'mediumTime')).toEqual('9:03:01 PM');
+          expect(pipe.transform(date, 'shortTime')).toEqual('9:03 PM');
+        });
+      });
+    }
+  });
+}

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

@@ -0,0 +1,51 @@
+import {I18nPluralPipe} from '@angular/common';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('I18nPluralPipe', () => {
+    var pipe: I18nPluralPipe;
+    var mapping = {'=0': 'No messages.', '=1': 'One message.', 'other': 'There are some messages.'};
+    var interpolatedMapping = {
+      '=0': 'No messages.',
+      '=1': 'One message.',
+      'other': 'There are # messages, that is #.'
+    };
+
+    beforeEach(() => { pipe = new I18nPluralPipe(); });
+
+    it('should be marked as pure',
+       () => { expect(new PipeResolver().resolve(I18nPluralPipe).pure).toEqual(true); });
+
+    describe('transform', () => {
+      it('should return 0 text if value is 0', () => {
+        var val = pipe.transform(0, mapping);
+        expect(val).toEqual('No messages.');
+      });
+
+      it('should return 1 text if value is 1', () => {
+        var val = pipe.transform(1, mapping);
+        expect(val).toEqual('One message.');
+      });
+
+      it('should return other text if value is anything other than 0 or 1', () => {
+        var val = pipe.transform(6, mapping);
+        expect(val).toEqual('There are some messages.');
+      });
+
+      it('should interpolate the value into the text where indicated', () => {
+        var val = pipe.transform(6, interpolatedMapping);
+        expect(val).toEqual('There are 6 messages, that is 6.');
+      });
+
+      it('should use \'other\' if value is undefined', () => {
+        var val = pipe.transform(void(0), interpolatedMapping);
+        expect(val).toEqual('There are  messages, that is .');
+      });
+
+      it('should not support bad arguments',
+         () => { expect(() => pipe.transform(0, <any>'hey')).toThrowError(); });
+    });
+
+  });
+}

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

@@ -0,0 +1,41 @@
+import {I18nSelectPipe} from '@angular/common';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('I18nSelectPipe', () => {
+    var pipe: I18nSelectPipe;
+    var mapping = {'male': 'Invite him.', 'female': 'Invite her.', 'other': 'Invite them.'};
+
+    beforeEach(() => { pipe = new I18nSelectPipe(); });
+
+    it('should be marked as pure',
+       () => { expect(new PipeResolver().resolve(I18nSelectPipe).pure).toEqual(true); });
+
+    describe('transform', () => {
+      it('should return male text if value is male', () => {
+        var val = pipe.transform('male', mapping);
+        expect(val).toEqual('Invite him.');
+      });
+
+      it('should return female text if value is female', () => {
+        var val = pipe.transform('female', mapping);
+        expect(val).toEqual('Invite her.');
+      });
+
+      it('should return other text if value is anything other than male or female', () => {
+        var val = pipe.transform('Anything else', mapping);
+        expect(val).toEqual('Invite them.');
+      });
+
+      it('should use \'other\' if value is undefined', () => {
+        var val = pipe.transform(void(0), mapping);
+        expect(val).toEqual('Invite them.');
+      });
+
+      it('should not support bad arguments',
+         () => { expect(() => pipe.transform('male', <any>'hey')).toThrowError(); });
+    });
+
+  });
+}

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

@@ -0,0 +1,74 @@
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach, inject,} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder} from '@angular/compiler/testing';
+import {Json, StringWrapper} from '../../src/facade/lang';
+
+import {Component} from '@angular/core';
+import {JsonPipe} from '@angular/common';
+
+export function main() {
+  describe('JsonPipe', () => {
+    var regNewLine = '\n';
+    var inceptionObj: any;
+    var inceptionObjString: string;
+    var pipe: JsonPipe;
+
+    function normalize(obj: string): string { return StringWrapper.replace(obj, regNewLine, ''); }
+
+    beforeEach(() => {
+      inceptionObj = {dream: {dream: {dream: 'Limbo'}}};
+      inceptionObjString = '{\n' +
+          '  "dream": {\n' +
+          '    "dream": {\n' +
+          '      "dream": "Limbo"\n' +
+          '    }\n' +
+          '  }\n' +
+          '}';
+
+
+      pipe = new JsonPipe();
+    });
+
+    describe('transform', () => {
+      it('should return JSON-formatted string',
+         () => { expect(pipe.transform(inceptionObj)).toEqual(inceptionObjString); });
+
+      it('should return JSON-formatted string even when normalized', () => {
+        var dream1 = normalize(pipe.transform(inceptionObj));
+        var dream2 = normalize(inceptionObjString);
+        expect(dream1).toEqual(dream2);
+      });
+
+      it('should return JSON-formatted string similar to Json.stringify', () => {
+        var dream1 = normalize(pipe.transform(inceptionObj));
+        var dream2 = normalize(Json.stringify(inceptionObj));
+        expect(dream1).toEqual(dream2);
+      });
+    });
+
+    describe('integration', () => {
+      it('should work with mutable objects',
+         inject(
+             [TestComponentBuilder, AsyncTestCompleter],
+             (tcb: TestComponentBuilder, async: AsyncTestCompleter) => {
+               tcb.createAsync(TestComp).then((fixture) => {
+                 let mutable: number[] = [1];
+                 fixture.debugElement.componentInstance.data = mutable;
+                 fixture.detectChanges();
+                 expect(fixture.debugElement.nativeElement).toHaveText('[\n  1\n]');
+
+                 mutable.push(2);
+                 fixture.detectChanges();
+                 expect(fixture.debugElement.nativeElement).toHaveText('[\n  1,\n  2\n]');
+
+                 async.done();
+               });
+             }));
+    });
+  });
+}
+
+@Component({selector: 'test-comp', template: '{{data | json}}', pipes: [JsonPipe]})
+class TestComp {
+  data: any;
+}

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

@@ -0,0 +1,34 @@
+import {LowerCasePipe} from '@angular/common';
+import {afterEach, beforeEach, ddescribe, describe, expect, iit, it, xit} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('LowerCasePipe', () => {
+    var upper: string;
+    var lower: string;
+    var pipe: LowerCasePipe;
+
+    beforeEach(() => {
+      lower = 'something';
+      upper = 'SOMETHING';
+      pipe = new LowerCasePipe();
+    });
+
+    describe('transform', () => {
+      it('should return lowercase', () => {
+        var val = pipe.transform(upper);
+        expect(val).toEqual(lower);
+      });
+
+      it('should lowercase when there is a new value', () => {
+        var val = pipe.transform(upper);
+        expect(val).toEqual(lower);
+        var val2 = pipe.transform('WAT');
+        expect(val2).toEqual('wat');
+      });
+
+      it('should not support other objects',
+         () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+    });
+
+  });
+}

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

@@ -0,0 +1,66 @@
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach,} from '@angular/core/testing/testing_internal';
+import {browserDetection} from '@angular/platform-browser/testing';
+
+import {DecimalPipe, PercentPipe, CurrencyPipe} from '@angular/common';
+
+export function main() {
+  describe('Number pipes', () => {
+    // TODO(mlaval): enable tests when Intl API is no longer used, see
+    // https://github.com/angular/angular/issues/3333
+    // Have to restrict to Chrome as IE uses a different formatting
+    if (browserDetection.supportsIntlApi && browserDetection.isChromeDesktop) {
+      describe('DecimalPipe', () => {
+        var pipe: DecimalPipe;
+
+        beforeEach(() => { pipe = new DecimalPipe(); });
+
+        describe('transform', () => {
+          it('should return correct value for numbers', () => {
+            expect(pipe.transform(12345)).toEqual('12,345');
+            expect(pipe.transform(123, '.2')).toEqual('123.00');
+            expect(pipe.transform(1, '3.')).toEqual('001');
+            expect(pipe.transform(1.1, '3.4-5')).toEqual('001.1000');
+            expect(pipe.transform(1.123456, '3.4-5')).toEqual('001.12346');
+            expect(pipe.transform(1.1234)).toEqual('1.123');
+          });
+
+          it('should not support other objects',
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
+        });
+      });
+
+      describe('PercentPipe', () => {
+        var pipe: PercentPipe;
+
+        beforeEach(() => { pipe = new PercentPipe(); });
+
+        describe('transform', () => {
+          it('should return correct value for numbers', () => {
+            expect(pipe.transform(1.23)).toEqual('123%');
+            expect(pipe.transform(1.2, '.2')).toEqual('120.00%');
+          });
+
+          it('should not support other objects',
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
+        });
+      });
+
+      describe('CurrencyPipe', () => {
+        var pipe: CurrencyPipe;
+
+        beforeEach(() => { pipe = new CurrencyPipe(); });
+
+        describe('transform', () => {
+          it('should return correct value for numbers', () => {
+            expect(pipe.transform(123)).toEqual('USD123');
+            expect(pipe.transform(12, 'EUR', false, '.2')).toEqual('EUR12.00');
+            expect(pipe.transform(5.123, 'USD', false, '.0-2')).toEqual('USD5.12');
+          });
+
+          it('should not support other objects',
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
+        });
+      });
+    }
+  });
+}