fix(compiler): support css stylesheets in offline compiler

Also add a configuration switch to disable the codegen, so we can
still use the metadata emit and tsickle pre-processing in the
build pipeline for angular itself.

.gitignore

@@ -21,6 +21,11 @@ tmp
 *.js.deps
 *.js.map
 
+# Files created by the template compiler
+**/*.ngfactory.ts
+**/*.css.ts
+**/*.css.shim.ts
+
 # Or type definitions we mirror from github
 # (NB: these lines are removed in publish-build-artifacts.sh)
 **/typings/**/*.d.ts
@@ -49,3 +54,6 @@ npm-debug.log
 
 # built dart payload tests
 /modules_dart/payload/**/build
+
+# rollup-test output
+/modules/rollup-test/dist/

.travis.yml

@@ -3,135 +3,190 @@ 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"}'
-    # GITHUB_TOKEN_ANGULAR
-    - secure: "fq/U7VDMWO8O8SnAQkdbkoSe2X92PVqg4d044HmRYVmcf6YbO48+xeGJ8yOk0pCBwl3ISO4Q2ot0x546kxfiYBuHkZetlngZxZCtQiFT9kyId8ZKcYdXaIW9OVdw3Gh3tQyUwDucfkVhqcs52D6NZjyE2aWZ4/d1V4kWRO/LMgo="
+#    - KARMA_JS_BROWSERS=ChromeNoSandbox
+#    - E2E_BROWSERS=ChromeOnTravis
+#    - LOGS_DIR=/tmp/angular-build/logs
+#    - ARCH=linux-x64
+
   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=lint
+   - CI_MODE=e2e
+   - CI_MODE=saucelabs_required
+   - CI_MODE=browserstack_required
 
-matrix:
-  allow_failures:
-    - env: "MODE=saucelabs_optional"
-    - env: "MODE=browserstack_optional"
-    # Tracked in https://github.com/angular/angular/issues/7050
-    - env: "MODE=typescript_next"
+#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
+  - ./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,234 @@
+<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 was 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)
 

README.md

@@ -1,18 +1,19 @@
-[![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular) 
+[![Build Status](https://travis-ci.org/angular/angular.svg?branch=master)](https://travis-ci.org/angular/angular)
 [![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)
 [![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 
+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 **Beta**.
 
 ## Quickstart
 

browser-providers.conf.js

@@ -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',
@@ -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,97 @@
+#!/usr/bin/env bash
+
+set -e -o pipefail
+
+cd `dirname $0`
+
+
+TSCONFIG=./modules/tsconfig.json
+echo "====== (all)COMPILING: \$(npm bin)/ng2tc -p ${TSCONFIG} ====="
+rm -rf ./dist/all/
+mkdir ./dist/all/
+
+# prepare all files 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/bundles/Rx.js .
+ln -s ../../../../node_modules/angular/angular.js .
+cd -
+
+# compile ts code
+$(npm bin)/ng2tc -p ${TSCONFIG}
+
+
+rm -rf ./dist/packages-dist
+
+for PACKAGE in \
+  core \
+  compiler \
+  common \
+  platform-browser \
+  platform-browser-dynamic \
+  platform-server \
+  http \
+  router \
+  router-deprecated \
+  upgrade
+do
+  SRCDIR=./modules/@angular/${PACKAGE}
+  DESTDIR=./dist/packages-dist/${PACKAGE}
+  UMDES6PATH=${DESTDIR}/esm/${PACKAGE}.umd.js
+  UMDES5PATH=${DESTDIR}/${PACKAGE}.umd.js
+
+
+  echo "======      COMPILING: \$(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es5.json        ====="
+  $(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es5.json
+  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
+
+
+  echo "====== (esm)COMPILING: \$(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es2015.json ====="
+  $(npm bin)/ng2tc -p ${SRCDIR}/tsconfig-es2015.json
+
+
+  echo "======      BUNDLING: ${SRCDIR} ====="
+  (
+    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"
+
+  # workaround for https://github.com/rollup/rollup/issues/626
+  if [[ ${TRAVIS} ]]; then
+    sed -i    "s/ class exports\./ class /g" ${DESTDIR}/esm/${PACKAGE}.umd.js
+  else
+    sed -i '' "s/ class exports\./ class /g" ${DESTDIR}/esm/${PACKAGE}.umd.js
+  fi
+
+  $(npm bin)/tsc  \
+      --out ${UMDES5PATH} \
+      --target es5 \
+      --allowJs \
+      ${UMDES6PATH} \
+      modules/\@angular/manual_typings/globals.d.ts \
+      modules/\@angular/typings/es6-collections/es6-collections.d.ts \
+      modules/\@angular/typings/es6-promise/es6-promise.d.ts
+  rm ${UMDES6PATH}
+
+done

gulpfile.js

@@ -155,6 +155,8 @@ var NG2_BUNDLE_CONTENT = ANGULAR2_BUNDLE_CONFIG.join(' + ') + ' - rxjs/*';
 var HTTP_BUNDLE_CONTENT = 'angular2/http - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var ROUTER_BUNDLE_CONTENT = 'angular2/router + angular2/router/router_link_dsl - rxjs/* - ' +
                             ANGULAR2_BUNDLE_CONFIG.join(' - ');
+var ALT_ROUTER_BUNDLE_CONTENT =
+    'angular2/alt_router - rxjs/* - ' + ANGULAR2_BUNDLE_CONFIG.join(' - ');
 var TESTING_BUNDLE_CONTENT =
     'angular2/testing + angular2/http/testing + angular2/router/testing + angular2/platform/testing/browser - rxjs/* - ' +
     ANGULAR2_BUNDLE_CONFIG.join(' - ');
@@ -177,8 +179,8 @@ var PAYLOAD_TESTS_CONFIG = {
       return path.join(__dirname, CONFIG.dest.js.prod.es5, 'payload_tests', caseName,
                        'ts/' + packaging);
     },
-    systemjs: {sizeLimits: {'uncompressed': 850 * 1024, 'gzip level=9': 165 * 1024}},
-    webpack: {sizeLimits: {'uncompressed': 550 * 1024, 'gzip level=9': 120 * 1024}}
+    systemjs: {sizeLimits: {'uncompressed': 880 * 1024, 'gzip level=9': 170 * 1024}},
+    webpack: {sizeLimits: {'uncompressed': 560 * 1024, 'gzip level=9': 130 * 1024}}
   }
 };
 
@@ -298,7 +300,14 @@ function doCheckFormat() {
   var clangFormat = require('clang-format');
   var gulpFormat = require('gulp-clang-format');
 
-  return gulp.src(['modules/**/*.ts', 'tools/**/*.ts', '!**/typings/**/*.d.ts', 'gulpfile.js'])
+  return gulp.src([
+               'modules/**/*.ts',
+               'tools/**/*.ts',
+               '!**/typings/**/*.d.ts',
+               // workaround https://github.com/angular/clang-format/issues/28
+               '!tools/compiler_cli/src/main.ts',
+               'gulpfile.js'
+             ])
       .pipe(gulpFormat.checkFormat('file', clangFormat));
 }
 
@@ -452,22 +461,40 @@ gulp.task('serve.e2e.dart', ['build.js.cjs'], function(neverDone) {
 // ------------------
 // CI tests suites
 
-function runKarma(configFile, done) {
+function execProcess(name, args, done) {
   var exec = require('child_process').exec;
 
-  var cmd = process.platform === 'win32' ? 'node_modules\\.bin\\karma run ' :
-                                           'node node_modules/.bin/karma run ';
-  cmd += configFile;
-  exec(cmd, function(e, stdout) {
+  var cmd = process.platform === 'win32' ? 'node_modules\\.bin\\' + name + ' ' :
+                                           'node node_modules/.bin/' + name + ' ';
+  cmd += args;
+  exec(cmd, done);
+}
+function runKarma(configFile, done) {
+  execProcess('karma', 'run ' + configFile, function(e, stdout) {
     // ignore errors, we don't want to fail the build in the interactive (non-ci) mode
     // karma server will print all test failures
     done();
   });
 }
 
+// Gulp-typescript doesn't work with typescript@next:
+// https://github.com/ivogabe/gulp-typescript/issues/331
+function runTsc(project, done) {
+  execProcess('tsc', '-p ' + project, function(e, stdout, stderr) {
+    if (e) {
+      console.log(stdout);
+      console.error(stderr);
+      done(e);
+    } else {
+      done();
+    }
+  });
+}
+
 gulp.task('test.js', function(done) {
-  runSequence('test.unit.tools/ci', 'test.transpiler.unittest', 'test.unit.js/ci',
-              'test.unit.cjs/ci', 'test.typings', 'check-public-api', sequenceComplete(done));
+  runSequence('test.compiler_cli', 'test.unit.tools/ci', 'test.transpiler.unittest',
+              'test.unit.js/ci', 'test.unit.cjs/ci', 'test.typings', 'check-public-api',
+              sequenceComplete(done));
 });
 
 gulp.task('test.dart', function(done) {
@@ -640,7 +667,7 @@ gulp.task('buildRouter.dev', function() {
 gulp.task('test.unit.dart', function(done) {
   printModulesWarning();
   runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-              '!build/change_detect.dart', '!build/remove-pub-symlinks', function(error) {
+              '!build/remove-pub-symlinks', function(error) {
                 var watch = require('./tools/build/watch');
 
                 // if initial build failed (likely due to build or formatting step) then exit
@@ -768,7 +795,7 @@ gulp.task('!checkAndReport.payload.js', function() {
                       {
                         failConditions: PAYLOAD_TESTS_CONFIG.ts[packaging].sizeLimits,
                         prefix: caseName + '_' + packaging
-                      })
+                      });
   }
 
   return PAYLOAD_TESTS_CONFIG.ts.cases.reduce(function(sizeReportingStreams, caseName) {
@@ -779,7 +806,7 @@ gulp.task('!checkAndReport.payload.js', function() {
 
 gulp.task('watch.dart.dev', function(done) {
   runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-              '!build/change_detect.dart', '!build/remove-pub-symlinks', function(error) {
+              '!build/remove-pub-symlinks', function(error) {
                 var watch = require('./tools/build/watch');
 
                 // if initial build failed (likely due to build or formatting step) then exit
@@ -789,7 +816,8 @@ gulp.task('watch.dart.dev', function(done) {
                   return;
                 }
 
-                watch(['modules/angular2/**'], {ignoreInitial: true}, ['!build/tree.dart']);
+                watch(['modules/angular2/**', 'modules_dart/**'], {ignoreInitial: true},
+                      ['!build/tree.dart', 'build/pure-packages.dart']);
               });
 });
 
@@ -895,7 +923,7 @@ gulp.task('test.unit.cjs/ci', function(done) {
   runJasmineTests(['dist/js/cjs/{angular2,benchpress}/test/**/*_spec.js'], done);
 });
 
-gulp.task('check-public-api',
+gulp.task('check-public-api', ['build.tools'],
           function(done) { runJasmineTests(['dist/tools/public_api_guard/**/*_spec.js'], done); });
 
 gulp.task('test.unit.cjs', ['build/clean.js', 'build.tools'], function(neverDone) {
@@ -911,21 +939,20 @@ gulp.task('test.unit.cjs', ['build/clean.js', 'build.tools'], function(neverDone
 gulp.task('test.unit.dartvm', function(neverDone) {
   var watch = require('./tools/build/watch');
 
-  runSequence(
-      'build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
-      '!build/change_detect.dart', '!test.unit.dartvm/run', function(error) {
-        // Watch for changes made in the TS and Dart code under "modules" and
-        // run ts2dart and test change detector generator prior to rerunning the
-        // tests.
-        watch('modules/angular2/**', {ignoreInitial: true},
-              ['!build/tree.dart', '!build/change_detect.dart', '!test.unit.dartvm/run']);
+  runSequence('build/tree.dart', 'build/pure-packages.dart', '!build/pubget.angular2.dart',
+              '!test.unit.dartvm/run', function(error) {
+                // Watch for changes made in the TS and Dart code under "modules" and
+                // run ts2dart and test change detector generator prior to rerunning the
+                // tests.
+                watch('modules/angular2/**', {ignoreInitial: true},
+                      ['!build/tree.dart', '!test.unit.dartvm/run']);
 
-        // Watch for changes made in Dart code under "modules_dart", then copy it
-        // to dist and run test change detector generator prior to retunning the
-        // tests.
-        watch('modules_dart/**', {ignoreInitial: true},
-              ['build/pure-packages.dart', '!build/change_detect.dart', '!test.unit.dartvm/run']);
-      });
+                // Watch for changes made in Dart code under "modules_dart", then copy it
+                // to dist and run test change detector generator prior to retunning the
+                // tests.
+                watch('modules_dart/**', {ignoreInitial: true},
+                      ['build/pure-packages.dart', '!test.unit.dartvm/run']);
+              });
 });
 
 gulp.task('!test.unit.dartvm/run',
@@ -981,9 +1008,9 @@ gulp.task('static-checks', ['!build.tools'], function(done) {
 // distributed in our npm package, and loaded from node_modules by
 // the typescript compiler.
 
-// Make sure the two typings tests are isolated, by running this one in a tempdir
+// Make sure the typings tests are isolated, by running in a tempdir
 var tmpdir = path.join(os.tmpdir(), 'test.typings', new Date().getTime().toString());
-gulp.task('!pre.test.typings.layoutNodeModule', ['build.js.cjs'], function() {
+gulp.task('!pre.test.typings.layoutNodeModule', function() {
   return gulp.src(['dist/js/cjs/angular2/**/*', 'node_modules/rxjs/**/*'], {base: 'dist/js/cjs'})
       .pipe(gulp.dest(path.join(tmpdir, 'node_modules')));
 });
@@ -1003,7 +1030,7 @@ gulp.task('!pre.test.typings.copyTypingsSpec', function() {
   return gulp.src(['modules/angular2/examples/**/*.ts']).pipe(gulp.dest(tmpdir));
 });
 
-gulp.task('test.typings',
+gulp.task('!test.typings',
           [
             '!pre.test.typings.layoutNodeModule',
             '!pre.test.typings.copyTypingsSpec',
@@ -1023,6 +1050,46 @@ gulp.task('test.typings',
                 }));
           });
 
+gulp.task('test.typings', ['build.js.cjs'],
+          function(done) { runSequence('!test.typings', sequenceComplete(done)); });
+
+gulp.task('!build.compiler_cli', function(done) { runTsc('tools/compiler_cli/src', done); });
+
+gulp.task('!clean.compiler_cli', function(done) {
+  fse.remove(path.join('dist', 'tools', 'compiler_cli', 'test'),
+             fse.remove(path.join('tools', 'compiler_cli', 'test', 'src', '*.ngfactory.ts'),
+                        fse.remove(path.join('tools', 'compiler_cli', 'test', 'src', 'a',
+                                             '*.ngfactory.ts'),
+                                   done)));
+});
+
+gulp.task('!test.compiler_cli.codegen', function(done) {
+  try {
+    require('./dist/tools/compiler_cli/main')
+        .main("tools/compiler_cli/test")
+        .then(done)
+        .catch(function(rej) { done(new Error(rej)); });
+  } catch (err) {
+    done(err);
+  }
+});
+
+gulp.task('!test.compiler_cli.unit',
+          function(done) { runJasmineTests(['dist/tools/compiler_cli/**/*_spec.js'], done) });
+
+// This task overwrites our careful tsickle-lowered Decorators with normal .js emit.
+// So it should only be run after asserting on the .js file content.
+gulp.task('!test.compiler_cli.verify_codegen',
+          function(done) { runTsc('tools/compiler_cli/test', done); });
+
+// End-to-end test for compiler CLI.
+// Calls the compiler using its command-line interface, then compiles the app with the codegen.
+// TODO(alexeagle): wire up the playground tests with offline compilation, similar to dart.
+gulp.task('test.compiler_cli', ['!build.compiler_cli'], function(done) {
+  runSequence('!clean.compiler_cli', '!test.compiler_cli.codegen', '!test.compiler_cli.unit',
+              '!test.compiler_cli.verify_codegen', sequenceComplete(done));
+});
+
 // -----------------
 // orchestrated targets
 
@@ -1066,9 +1133,9 @@ gulp.task('build/pure-packages.dart/angular2', function() {
 
 // Builds all Dart packages, but does not compile them
 gulp.task('build/packages.dart', function(done) {
-  runSequence('lint_protos.dart', 'build/tree.dart', 'build/pure-packages.dart',
+  runSequence('lint_protos.dart', 'pubget.dart', 'build/tree.dart', 'build/pure-packages.dart',
               // Run after 'build/tree.dart' because broccoli clears the dist/dart folder
-              '!build/pubget.angular2.dart', '!build/change_detect.dart', sequenceComplete(done));
+              '!build/pubget.angular2.dart', sequenceComplete(done));
 });
 
 // Builds and compiles all Dart packages
@@ -1088,7 +1155,7 @@ gulp.task('!build.tools', function() {
   var sourcemaps = require('gulp-sourcemaps');
   var tsc = require('gulp-typescript');
 
-  var stream = gulp.src(['tools/**/*.ts'])
+  var stream = gulp.src(['tools/**/*.ts', '!tools/compiler_cli/**'])
                    .pipe(sourcemaps.init())
                    .pipe(tsc({
                      target: 'ES5',
@@ -1194,6 +1261,8 @@ gulp.task('!bundle.js.prod', ['build.js.prod'], function() {
           bundler.bundle(bundleConfig, HTTP_BUNDLE_CONTENT, './dist/build/http.js', bundlerConfig),
           bundler.bundle(bundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.js',
                          bundlerConfig),
+          bundler.bundle(bundleConfig, ALT_ROUTER_BUNDLE_CONTENT, './dist/build/alt_router.js',
+                         bundlerConfig),
           bundler.bundle(bundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.js',
                          bundlerConfig)
         ]);
@@ -1203,7 +1272,8 @@ gulp.task('!bundle.js.prod', ['build.js.prod'], function() {
 // minified production build
 gulp.task('!bundle.js.min', ['build.js.prod'], function() {
   var bundler = require('./tools/build/bundle');
-  var bundlerConfig = {sourceMaps: true, minify: true};
+  var bundlerConfig =
+      {sourceMaps: true, minify: true, mangle: false, uglify: {compress: {keep_fnames: true}}};
 
   return bundler.bundle(bundleConfig, NG2_BUNDLE_CONTENT, './dist/build/angular2.min.js',
                         bundlerConfig)
@@ -1213,6 +1283,8 @@ gulp.task('!bundle.js.min', ['build.js.prod'], function() {
                          bundlerConfig),
           bundler.bundle(bundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.min.js',
                          bundlerConfig),
+          bundler.bundle(bundleConfig, ALT_ROUTER_BUNDLE_CONTENT, './dist/build/alt_router.min.js',
+                         bundlerConfig),
           bundler.bundle(bundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.min.js',
                          bundlerConfig)
         ]);
@@ -1235,6 +1307,8 @@ gulp.task('!bundle.js.dev', ['build.js.dev'], function() {
                          bundlerConfig),
           bundler.bundle(devBundleConfig, ROUTER_BUNDLE_CONTENT, './dist/build/router.dev.js',
                          bundlerConfig),
+          bundler.bundle(devBundleConfig, ALT_ROUTER_BUNDLE_CONTENT,
+                         './dist/build/alt_router.dev.js', bundlerConfig),
           bundler.bundle(devBundleConfig, UPGRADE_BUNDLE_CONTENT, './dist/build/upgrade.dev.js',
                          bundlerConfig)
         ]);
@@ -1355,6 +1429,7 @@ gulp.task('!bundle.js.prod.deps', ['!bundle.js.prod'], function() {
   return merge2(bundler.modify(['dist/build/angular2.js'], 'angular2.js'),
                 bundler.modify(['dist/build/http.js'], 'http.js'),
                 bundler.modify(['dist/build/router.js'], 'router.js'),
+                bundler.modify(['dist/build/alt_router.js'], 'alt_router.js'),
                 bundler.modify(['dist/build/upgrade.js'], 'upgrade.js'))
       .pipe(gulp.dest('dist/js/bundle'));
 });
@@ -1366,6 +1441,7 @@ gulp.task('!bundle.js.min.deps', ['!bundle.js.min'], function() {
   return merge2(bundler.modify(['dist/build/angular2.min.js'], 'angular2.min.js'),
                 bundler.modify(['dist/build/http.min.js'], 'http.min.js'),
                 bundler.modify(['dist/build/router.min.js'], 'router.min.js'),
+                bundler.modify(['dist/build/alt_router.min.js'], 'alt_router.min.js'),
                 bundler.modify(['dist/build/upgrade.min.js'], 'upgrade.min.js'))
       .pipe(uglify())
       .pipe(gulp.dest('dist/js/bundle'));
@@ -1397,6 +1473,7 @@ gulp.task('!bundle.js.dev.deps', ['!bundle.js.dev'], function() {
   return merge2(bundler.modify(['dist/build/angular2.dev.js'], 'angular2.dev.js'),
                 bundler.modify(['dist/build/http.dev.js'], 'http.dev.js'),
                 bundler.modify(['dist/build/router.dev.js'], 'router.dev.js'),
+                bundler.modify(['dist/build/alt_router.dev.js'], 'alt_router.dev.js'),
                 bundler.modify(['dist/build/upgrade.dev.js'], 'upgrade.dev.js'))
       .pipe(gulp.dest('dist/js/bundle'));
 });
@@ -1463,34 +1540,6 @@ gulp.task('gen_protos.dart', function(done) {
       done);
 });
 
-// change detection codegen
-gulp.task('build.change_detect.dart', function(done) {
-  return runSequence('build/packages.dart', '!build/pubget.angular2.dart',
-                     '!build/change_detect.dart', done);
-});
-
-gulp.task('!build/change_detect.dart', function(done) {
-  var fs = require('fs');
-  var spawn = require('child_process').spawn;
-
-  var changeDetectDir = path.join(CONFIG.dest.dart, 'angular2/test/core/change_detection/');
-  var srcDir = path.join(changeDetectDir, 'generator');
-  var destDir = path.join(changeDetectDir, 'generated');
-
-  var dartStream = fs.createWriteStream(path.join(destDir, 'change_detector_classes.dart'));
-  var genMain = path.join(srcDir, 'gen_change_detectors.dart');
-  var proc = spawn(DART_SDK.VM, [genMain], {stdio: ['ignore', 'pipe', 'inherit']});
-  proc.on('error', function(code) {
-    done(new Error('Failed while generating change detector classes. Please run manually: ' +
-                   DART_SDK.VM + ' ' + dartArgs.join(' ')));
-  });
-  proc.on('close', function() {
-    dartStream.close();
-    done();
-  });
-  proc.stdout.pipe(dartStream);
-});
-
 // ------------
 
 gulp.task('cleanup.builder', function() { return angularBuilder.cleanup(); });
@@ -1530,13 +1579,16 @@ process.on('beforeExit', function() {
 
 
 var firstTask = true;
+
+
+
 gulp.on('task_start', (e) => {
   if (firstTask) {
     firstTask = false;
     analytics.buildSuccess('gulp <startup>', process.uptime() * 1000);
   }
 
-  analytics.buildStart('gulp ' + e.task)
+  analytics.buildStart('gulp ' + e.task);
 });
-gulp.on('task_stop', (e) => {analytics.buildSuccess('gulp ' + e.task, e.duration * 1000)});
-gulp.on('task_err', (e) => {analytics.buildError('gulp ' + e.task, e.duration * 1000)});
+gulp.on('task_stop', (e) => { analytics.buildSuccess('gulp ' + e.task, e.duration * 1000); });
+gulp.on('task_err', (e) => { analytics.buildError('gulp ' + e.task, e.duration * 1000); });

karma-js.conf.js

@@ -11,7 +11,8 @@ 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},
+      {pattern: 'dist/all/angular2/**/*.js', included: false, watched: true},
 
       'node_modules/es6-shim/es6-shim.js',
       // include Angular v1 for upgrade module testing
@@ -20,18 +21,27 @@ 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-dynamic/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/angular1_router.js',
+      'dist/all/@angular/platform-browser/testing/e2e_util.js'
+    ],
 
     customLaunchers: browserProvidersConf.customLaunchers,
 
@@ -52,6 +62,7 @@ module.exports = function(config) {
     reporters: ['internal-angular'],
     sauceLabs: {
       testName: 'Angular2',
+      retryLimit: 3,
       startConnect: false,
       recordVideo: false,
       recordScreenshots: false,
@@ -66,19 +77,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 +103,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';
+export * from './src/common_directives';
+export * from './src/location';

modules/@angular/common/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@angular/common",
+  "version": "$$ANGULAR_VERSION$$",
+  "description": "",
+  "main": "index.js",
+  "jsnext:main": "esm/index.js",
+  "typings": "index.d.ts",
+  "author": "angular",
+  "license": "MIT",
+  "peerDependencies": {
+    "@angular/core": "$$ANGULAR_VERSION$$"
+  }
+}

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

@@ -0,0 +1,18 @@
+
+export default {
+  entry: '../../../dist/packages-dist/common/esm/index.js',
+  dest: '../../../dist/packages-dist/common/esm/common.umd.js',
+  sourceMap: true,
+  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,5 +1,4 @@
-import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
-
+import {Type} from '@angular/core';
 import {FORM_DIRECTIVES} from './forms';
 import {CORE_DIRECTIVES} from './directives';
 
@@ -17,7 +16,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 +32,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({
@@ -46,4 +45,4 @@ import {CORE_DIRECTIVES} from './directives';
  * }
  * ```
  */
-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

@@ -6,6 +6,7 @@
 export {NgClass} from './directives/ng_class';
 export {NgFor} from './directives/ng_for';
 export {NgIf} from './directives/ng_if';
+export {NgTemplateOutlet} from './directives/ng_template_outlet';
 export {NgStyle} from './directives/ng_style';
 export {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './directives/ng_switch';
 export {NgPlural, NgPluralCase, NgLocalization} from './directives/ng_plural';

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

@@ -1,7 +1,8 @@
-import {CONST_EXPR, Type} from 'angular2/src/facade/lang';
+import {Type} from '../../src/facade/lang';
 import {NgClass} from './ng_class';
 import {NgFor} from './ng_for';
 import {NgIf} from './ng_if';
+import {NgTemplateOutlet} from './ng_template_outlet';
 import {NgStyle} from './ng_style';
 import {NgSwitch, NgSwitchWhen, NgSwitchDefault} from './ng_switch';
 import {NgPlural, NgPluralCase} from './ng_plural';
@@ -18,7 +19,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 +34,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({
@@ -46,14 +47,15 @@ import {NgPlural, NgPluralCase} from './ng_plural';
  * }
  * ```
  */
-export const CORE_DIRECTIVES: Type[] = CONST_EXPR([
+export const CORE_DIRECTIVES: Type[] = /*@ts2dart_const*/[
   NgClass,
   NgFor,
   NgIf,
+  NgTemplateOutlet,
   NgStyle,
   NgSwitch,
   NgSwitchWhen,
   NgSwitchDefault,
   NgPlural,
   NgPluralCase
-]);
+];

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

@@ -1,4 +1,3 @@
-import {isPresent, isString, isArray} from 'angular2/src/facade/lang';
 import {
   DoCheck,
   OnDestroy,
@@ -11,8 +10,9 @@ import {
   KeyValueDiffer,
   CollectionChangeRecord,
   KeyValueChangeRecord
-} from 'angular2/core';
-import {StringMapWrapper, isListLikeIterable} from 'angular2/src/facade/collection';
+} from '@angular/core';
+import {isPresent, isString, isArray} from '../../src/facade/lang';
+import {StringMapWrapper, isListLikeIterable} from '../../src/facade/collection';
 
 /**
  * The `NgClass` directive conditionally adds and removes CSS classes on an HTML element based on
@@ -33,8 +33,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',

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

@@ -7,31 +7,43 @@ import {
   ViewContainerRef,
   TemplateRef,
   EmbeddedViewRef,
-  TrackByFn
-} from 'angular2/core';
-import {isPresent, isBlank, stringify, getTypeNameForDebugging} from 'angular2/src/facade/lang';
-import {
+  TrackByFn,
   DefaultIterableDiffer,
   CollectionChangeRecord
-} from "../../core/change_detection/differs/default_iterable_differ";
-import {BaseException} from "../../facade/exceptions";
+} from '@angular/core';
+import {isPresent, isBlank, getTypeNameForDebugging} from '../../src/facade/lang';
+import {BaseException} from '../../src/facade/exceptions';
+
+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,9 +66,9 @@ 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 *ngFor="let 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>`
  *
@@ -69,10 +81,11 @@ import {BaseException} from "../../facade/exceptions";
 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 +100,7 @@ export class NgFor implements DoCheck {
     }
   }
 
-  set ngForTemplate(value: TemplateRef) {
+  set ngForTemplate(value: TemplateRef<NgForRow>) {
     if (isPresent(value)) {
       this._templateRef = value;
     }
@@ -124,21 +137,19 @@ 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);
+      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[] {
@@ -149,7 +160,8 @@ export class NgFor implements DoCheck {
       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 +177,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 +186,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,5 @@
-import {Directive, ViewContainerRef, TemplateRef} from 'angular2/core';
-import {isBlank} from 'angular2/src/facade/lang';
+import {Directive, ViewContainerRef, TemplateRef} from '@angular/core';
+import {isBlank} from '../../src/facade/lang';
 
 /**
  * Removes or recreates a portion of the DOM tree based on an {expression}.
@@ -27,7 +27,8 @@ import {isBlank} from 'angular2/src/facade/lang';
 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

@@ -7,9 +7,10 @@ import {
   Attribute,
   AfterContentInit,
   Input
-} from 'angular2/core';
-import {isPresent, NumberWrapper} from 'angular2/src/facade/lang';
-import {Map} from 'angular2/src/facade/collection';
+} from '@angular/core';
+import {isPresent, NumberWrapper} from '../../src/facade/lang';
+import {Map} from '../../src/facade/collection';
+
 import {SwitchView} from './ng_switch';
 
 const _CATEGORY_DEFAULT = 'other';
@@ -74,8 +75,9 @@ export abstract class NgLocalization { abstract getPluralCategory(value: any): s
 
 @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);
   }

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

@@ -1,3 +1,4 @@
+import {KeyValueChangeRecord} from '@angular/core';
 import {
   DoCheck,
   KeyValueDiffer,
@@ -5,9 +6,8 @@ import {
   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";
+} from '@angular/core';
+import {isPresent, isBlank} from '../../src/facade/lang';
 
 /**
  * The `NgStyle` directive changes styles based on a result of expression evaluation.
@@ -24,8 +24,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',

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

@@ -1,11 +1,12 @@
-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, ViewContainerRef, TemplateRef} from '@angular/core';
+import {isPresent, isBlank, normalizeBlank} from '../../src/facade/lang';
+import {ListWrapper, Map} from '../../src/facade/collection';
 
-const _WHEN_DEFAULT = CONST_EXPR(new Object());
+const _WHEN_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); }
 
@@ -21,7 +22,7 @@ export class SwitchView {
  * `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
+ * `[ngSwitch]="..."` attribute), define any inner elements inside of the directive and
  * place a `[ngSwitchWhen]` attribute per element.
  *
  * The `ngSwitchWhen` property is used to inform `NgSwitch` which element to display when the
@@ -175,7 +176,7 @@ export class NgSwitchWhen {
   _view: SwitchView;
   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);
@@ -195,7 +196,7 @@ export class NgSwitchWhen {
  */
 @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));
   }

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

@@ -0,0 +1,26 @@
+import {Directive, Input, ViewContainerRef, ViewRef, TemplateRef} from '@angular/core';
+import {isPresent} from '../../src/facade/lang';
+
+/**
+ * Creates and inserts an embedded view based on a prepared `TemplateRef`.
+ *
+ * ### Syntax
+ * - `<template [ngTemplateOutlet]="templateRefExpression"></template>`
+ */
+@Directive({selector: '[ngTemplateOutlet]'})
+export class NgTemplateOutlet {
+  private _insertedViewRef: ViewRef;
+
+  constructor(private _viewContainerRef: ViewContainerRef) {}
+
+  @Input()
+  set ngTemplateOutlet(templateRef: TemplateRef<Object>) {
+    if (isPresent(this._insertedViewRef)) {
+      this._viewContainerRef.remove(this._viewContainerRef.indexOf(this._insertedViewRef));
+    }
+
+    if (isPresent(templateRef)) {
+      this._insertedViewRef = this._viewContainerRef.createEmbeddedView(templateRef);
+    }
+  }
+}

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

@@ -1,7 +1,7 @@
 // TS does not have Observables
 
 // I need to be here to make TypeScript think this is a module.
-import {} from 'angular2/src/facade/lang';
+import {} from '../../src/facade/lang';
 
 /**
  * This module exists in Dart, but not in Typescript. This exported symbol

modules/@angular/common/src/facade

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

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

@@ -7,9 +7,8 @@
  * to read information
  * from the form DOM elements.
  *
- * This module is not included in the `angular2` module; you must import the forms module
+ * Forms providers are not included in default providers; you must import these providers
  * explicitly.
- *
  */
 export {AbstractControl, Control, ControlGroup, ControlArray} from './forms/model';
 
@@ -43,7 +42,7 @@ export {
 export {FormBuilder} from './forms/form_builder';
 import {FormBuilder} from './forms/form_builder';
 import {RadioControlRegistry} from './forms/directives/radio_control_value_accessor';
-import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
+import {Type} from '@angular/core';
 
 /**
  * Shorthand set of providers used for building Angular forms.
@@ -54,11 +53,11 @@ import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
  * bootstrap(MyApp, [FORM_PROVIDERS]);
  * ```
  */
-export const FORM_PROVIDERS: Type[] = CONST_EXPR([FormBuilder, RadioControlRegistry]);
+export const FORM_PROVIDERS: Type[] = /*@ts2dart_const*/[FormBuilder, RadioControlRegistry];
 
 /**
  * See {@link FORM_PROVIDERS} instead.
  *
  * @deprecated
  */
-export const FORM_BINDINGS = FORM_PROVIDERS;
+export const FORM_BINDINGS = /*@ts2dart_const*/ FORM_PROVIDERS;

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

@@ -1,4 +1,4 @@
-import {Type, CONST_EXPR} from 'angular2/src/facade/lang';
+import {Type} from '@angular/core';
 import {NgControlName} from './directives/ng_control_name';
 import {NgFormControl} from './directives/ng_form_control';
 import {NgModel} from './directives/ng_model';
@@ -64,7 +64,7 @@ export {ControlValueAccessor} from './directives/control_value_accessor';
  * class MyApp {}
  * ```
  */
-export const FORM_DIRECTIVES: Type[] = CONST_EXPR([
+export const FORM_DIRECTIVES: Type[] = /*@ts2dart_const*/[
   NgControlName,
   NgControlGroup,
 
@@ -85,4 +85,4 @@ export const FORM_DIRECTIVES: Type[] = CONST_EXPR([
   MinLengthValidator,
   MaxLengthValidator,
   PatternValidator
-]);
+];

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

@@ -1,6 +1,6 @@
 import {AbstractControl} from '../model';
-import {isPresent} from 'angular2/src/facade/lang';
-import {unimplemented} from 'angular2/src/facade/exceptions';
+import {isPresent} from '../../../src/facade/lang';
+import {unimplemented} from '../../../src/facade/exceptions';
 
 /**
  * Base class for control directives.

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

@@ -1,10 +1,11 @@
-import {Directive, Renderer, ElementRef, Self, forwardRef, Provider} from 'angular2/core';
-
+import {Directive, Renderer, ElementRef, Self, forwardRef, Provider} from '@angular/core';
 import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
 
-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.

modules/@angular/common/src/forms/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.
@@ -31,4 +30,5 @@ export interface ControlValueAccessor {
  *
  * See {@link DefaultValueAccessor} for how to implement one.
  */
-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/directives/default_value_accessor.ts

@@ -1,9 +1,13 @@
-import {Directive, ElementRef, Renderer, Self, forwardRef, Provider} from 'angular2/core';
+import {Directive, ElementRef, Renderer, forwardRef} from '@angular/core';
+import {isBlank} from '../../../src/facade/lang';
 import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {isBlank, CONST_EXPR} from 'angular2/src/facade/lang';
 
-const DEFAULT_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => DefaultValueAccessor), multi: true}));
+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

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

@@ -42,4 +42,4 @@ export interface Form {
    * Update the model for a particular control with a new value.
    */
   updateModel(dir: NgControl, value: any): void;
-}
+}

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

@@ -1,6 +1,7 @@
+import {unimplemented} from '../../../src/facade/exceptions';
+
 import {ControlValueAccessor} from './control_value_accessor';
 import {AbstractControlDirective} from './abstract_control_directive';
-import {unimplemented} from 'angular2/src/facade/exceptions';
 import {AsyncValidatorFn, ValidatorFn} from './validators';
 
 /**

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

@@ -9,9 +9,7 @@ import {
   forwardRef,
   Provider,
   Self
-} from 'angular2/core';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-
+} from '@angular/core';
 import {ControlContainer} from './control_container';
 import {controlPath, composeValidators, composeAsyncValidators} from './shared';
 import {ControlGroup} from '../model';
@@ -19,8 +17,11 @@ import {Form} from './form_interface';
 import {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
 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.
@@ -35,7 +36,7 @@ const controlGroupProvider =
  *   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">
  *           <h3>Enter your name:</h3>
@@ -52,8 +53,7 @@ const controlGroupProvider =
  *         <pre>{{valueOf(f)}}</pre>
  *       </form>
  *     </div>
- *   `,
- *   directives: [FORM_DIRECTIVES]
+ *   `
  * })
  * export class App {
  *   valueOf(cg: NgControlGroup): string {

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

@@ -1,6 +1,3 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
-
 import {
   OnChanges,
   OnDestroy,
@@ -14,8 +11,9 @@ import {
   Inject,
   Optional,
   Self
-} from 'angular2/core';
+} from '@angular/core';
 
+import {EventEmitter, ObservableWrapper} from '../../../src/facade/async';
 import {ControlContainer} from './control_container';
 import {NgControl} from './ng_control';
 import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
@@ -31,8 +29,11 @@ import {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
 import {ValidatorFn, AsyncValidatorFn} 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.

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

@@ -1,6 +1,6 @@
-import {Directive, Self} from 'angular2/core';
+import {Directive, Self} from '@angular/core';
 import {NgControl} from './ng_control';
-import {isBlank, isPresent} from 'angular2/src/facade/lang';
+import {isPresent} from '../../../src/facade/lang';
 
 /**
  * Directive automatically applied to Angular forms that sets CSS classes

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

@@ -1,22 +1,22 @@
+import {Directive, forwardRef, Provider, Optional, Inject, Self} from '@angular/core';
 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';
+} from '../../../src/facade/async';
+import {ListWrapper} from '../../../src/facade/collection';
+import {isPresent} from '../../../src/facade/lang';
 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 {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
 
-const formDirectiveProvider =
-    CONST_EXPR(new Provider(ControlContainer, {useExisting: forwardRef(() => NgForm)}));
+export const formDirectiveProvider: any =
+    /*@ts2dart_const*/ {provide: ControlContainer, useExisting: forwardRef(() => NgForm)};
 
 /**
  * If `NgForm` is bound in a component, `<form>` elements in that component will be

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

@@ -1,6 +1,3 @@
-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,
@@ -11,10 +8,14 @@ import {
   Inject,
   Optional,
   Self
-} from 'angular2/core';
+} from '@angular/core';
+
+import {StringMapWrapper} from '../../../src/facade/collection';
+import {EventEmitter, ObservableWrapper} from '../../../src/facade/async';
+
 import {NgControl} from './ng_control';
 import {Control} from '../model';
-import {Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
+import {NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
 import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
 import {
   setUpControl,
@@ -25,8 +26,11 @@ import {
 } from './shared';
 import {ValidatorFn, AsyncValidatorFn} from './validators';
 
-const formControlBinding =
-    CONST_EXPR(new Provider(NgControl, {useExisting: forwardRef(() => NgFormControl)}));
+export const formControlBinding: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: NgControl,
+      useExisting: forwardRef(() => NgFormControl)
+    };
 
 /**
  * Binds an existing {@link Control} to a DOM element.
@@ -57,7 +61,7 @@ const formControlBinding =
  * }
  *  ```
  *
- * ###ngModel
+ * ### ngModel
  *
  * We can also use `ngModel` to bind a domain model to the form.
  *

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

@@ -1,6 +1,3 @@
-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,
@@ -10,7 +7,11 @@ import {
   Inject,
   Optional,
   Self
-} from 'angular2/core';
+} from '@angular/core';
+import {isBlank} from '../../../src/facade/lang';
+import {ListWrapper, StringMapWrapper} from '../../../src/facade/collection';
+import {BaseException} from '../../../src/facade/exceptions';
+import {ObservableWrapper, EventEmitter} from '../../../src/facade/async';
 import {NgControl} from './ng_control';
 import {NgControlGroup} from './ng_control_group';
 import {ControlContainer} from './control_container';
@@ -19,8 +20,11 @@ import {Control, ControlGroup} from '../model';
 import {setUpControl, setUpControlGroup, composeValidators, composeAsyncValidators} from './shared';
 import {Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS} from '../validators';
 
-const formDirectiveProvider =
-    CONST_EXPR(new Provider(ControlContainer, {useExisting: forwardRef(() => NgFormModel)}));
+export const formDirectiveProvider: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: ControlContainer,
+      useExisting: forwardRef(() => NgFormModel)
+    };
 
 /**
  * Binds an existing control group to a DOM element.
@@ -114,6 +118,7 @@ export class NgFormModel extends ControlContainer implements Form,
   }
 
   ngOnChanges(changes: {[key: string]: SimpleChange}): void {
+    this._checkFormPresent();
     if (StringMapWrapper.contains(changes, "form")) {
       var sync = composeValidators(this._validators);
       this.form.validator = Validators.compose([this.form.validator, sync]);
@@ -173,4 +178,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/directives/ng_model.ts

@@ -1,5 +1,3 @@
-import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {
   OnChanges,
   SimpleChange,
@@ -9,7 +7,8 @@ import {
   Inject,
   Optional,
   Self
-} from 'angular2/core';
+} from '@angular/core';
+import {EventEmitter, ObservableWrapper} from '../../../src/facade/async';
 import {ControlValueAccessor, NG_VALUE_ACCESSOR} from './control_value_accessor';
 import {NgControl} from './ng_control';
 import {Control} from '../model';
@@ -23,8 +22,11 @@ import {
 } from './shared';
 import {ValidatorFn, AsyncValidatorFn} from './validators';
 
-const formControlBinding =
-    CONST_EXPR(new Provider(NgControl, {useExisting: forwardRef(() => NgModel)}));
+export const formControlBinding: any =
+    /*@ts2dart_const*/ /* @ts2dart_Provider */ {
+      provide: NgControl,
+      useExisting: forwardRef(() => NgModel)
+    };
 
 /**
  * Binds a domain model to a form control.

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

@@ -1,4 +1,4 @@
-import {AbstractControl} from "../model";
+import {AbstractControl} from '../model';
 import {Validator, ValidatorFn, AsyncValidatorFn} from './validators';
 
 export function normalizeValidator(validator: ValidatorFn | Validator): ValidatorFn {

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

@@ -1,9 +1,12 @@
-import {Directive, ElementRef, Renderer, Self, forwardRef, Provider} from 'angular2/core';
+import {Directive, ElementRef, Renderer, Self, forwardRef, Provider} from '@angular/core';
+import {NumberWrapper} from '../../../src/facade/lang';
 import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
-import {isBlank, CONST_EXPR, NumberWrapper} from 'angular2/src/facade/lang';
 
-const NUMBER_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => NumberValueAccessor), multi: true}));
+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
@@ -35,7 +38,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/directives/radio_control_value_accessor.ts

@@ -2,27 +2,24 @@ import {
   Directive,
   ElementRef,
   Renderer,
-  Self,
   forwardRef,
   Provider,
-  Attribute,
   Input,
   OnInit,
   OnDestroy,
   Injector,
   Injectable
-} from 'angular2/core';
-import {
-  NG_VALUE_ACCESSOR,
-  ControlValueAccessor
-} from 'angular2/src/common/forms/directives/control_value_accessor';
-import {NgControl} from 'angular2/src/common/forms/directives/ng_control';
-import {CONST_EXPR, looseIdentical, isPresent} from 'angular2/src/facade/lang';
-import {ListWrapper} from 'angular2/src/facade/collection';
-
-const RADIO_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => RadioControlValueAccessor), multi: true}));
+} from '@angular/core';
+import {isPresent} from '../../../src/facade/lang';
+import {ListWrapper} from '../../../src/facade/collection';
+import {NG_VALUE_ACCESSOR, ControlValueAccessor} 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.
@@ -88,9 +85,12 @@ export class RadioButtonState {
 })
 export class RadioControlValueAccessor implements ControlValueAccessor,
     OnDestroy, OnInit {
+  /** @internal */
   _state: RadioButtonState;
+  /** @internal */
   _control: NgControl;
   @Input() name: string;
+  /** @internal */
   _fn: Function;
   onChange = () => {};
   onTouched = () => {};

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

@@ -8,21 +8,23 @@ import {
   Host,
   OnDestroy,
   Optional
-} from 'angular2/core';
-import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
+} from '@angular/core';
 import {
-  CONST_EXPR,
   StringWrapper,
   isPrimitive,
   isPresent,
   isBlank,
   looseIdentical
-} from 'angular2/src/facade/lang';
+} from '../../../src/facade/lang';
+import {MapWrapper} from '../../../src/facade/collection';
 
-import {MapWrapper} from 'angular2/src/facade/collection';
+import {NG_VALUE_ACCESSOR, ControlValueAccessor} from './control_value_accessor';
 
-const SELECT_VALUE_ACCESSOR = CONST_EXPR(new Provider(
-    NG_VALUE_ACCESSOR, {useExisting: forwardRef(() => SelectControlValueAccessor), multi: true}));
+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}`;
@@ -36,15 +38,23 @@ function _extractId(valueString: string): string {
 
 /**
  * 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/
+ *
  */
 @Directive({
   selector: 'select[ngControl],select[ngFormControl],select[ngModel]',
-  host: {'(input)': 'onChange($event.target.value)', '(blur)': 'onTouched()'},
+  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) => {};
@@ -63,8 +73,10 @@ export class SelectControlValueAccessor implements ControlValueAccessor {
   }
   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;
@@ -72,6 +84,7 @@ export class SelectControlValueAccessor implements ControlValueAccessor {
     return null;
   }
 
+  /** @internal */
   _getOptionValue(valueString: string): any {
     let value = this._optionMap.get(_extractId(valueString));
     return isPresent(value) ? value : valueString;
@@ -85,7 +98,7 @@ export class SelectControlValueAccessor implements ControlValueAccessor {
  *
  * ```
  * <select ngControl="city">
- *   <option *ngFor="#c of cities" [value]="c"></option>
+ *   <option *ngFor="let c of cities" [value]="c"></option>
  * </select>
  * ```
  */
@@ -108,11 +121,11 @@ export class NgSelectOption implements OnDestroy {
 
   @Input('value')
   set value(value: any) {
-    if (this._select == null) return;
     this._setElementValue(value);
-    this._select.writeValue(this._select.value);
+    if (isPresent(this._select)) this._select.writeValue(this._select.value);
   }
 
+  /** @internal */
   _setElementValue(value: string): void {
     this._renderer.setElementProperty(this._element.nativeElement, 'value', value);
   }

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

@@ -1,6 +1,6 @@
-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 {ListWrapper, StringMapWrapper} from '../../../src/facade/collection';
+import {isBlank, isPresent, looseIdentical, hasConstructor} from '../../../src/facade/lang';
+import {BaseException} from '../../../src/facade/exceptions';
 
 import {ControlContainer} from './control_container';
 import {NgControl} from './ng_control';

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

@@ -1,9 +1,8 @@
-import {forwardRef, Provider, Attribute, Directive} from 'angular2/core';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+import {forwardRef, Attribute, Directive} from '@angular/core';
+import {NumberWrapper} from '../../facade/lang';
 import {Validators, NG_VALIDATORS} from '../validators';
 import {AbstractControl} from '../model';
 import * as modelModule from '../model';
-import {NumberWrapper} from "angular2/src/facade/lang";
 
 
 
@@ -26,10 +25,13 @@ import {NumberWrapper} from "angular2/src/facade/lang";
  */
 export interface Validator { validate(c: modelModule.AbstractControl): {[key: string]: any}; }
 
-const REQUIRED = Validators.required;
+const REQUIRED = /*@ts2dart_const*/ Validators.required;
 
-const REQUIRED_VALIDATOR =
-    CONST_EXPR(new Provider(NG_VALIDATORS, {useValue: REQUIRED, multi: true}));
+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
@@ -60,8 +62,11 @@ 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`,
@@ -88,8 +93,11 @@ 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`,
@@ -122,8 +130,11 @@ export class MaxLengthValidator implements Validator {
  * <input [ngControl]="fullName" pattern="[a-zA-Z ]*">
  * ```
  */
-const PATTERN_VALIDATOR = CONST_EXPR(
-    new Provider(NG_VALIDATORS, {useExisting: forwardRef(() => PatternValidator), multi: true}));
+export const PATTERN_VALIDATOR: any = /*@ts2dart_const*/ /*@ts2dart_Provider*/ {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => PatternValidator),
+  multi: true
+};
 @Directive({
   selector: '[pattern][ngControl],[pattern][ngFormControl],[pattern][ngModel]',
   providers: [PATTERN_VALIDATOR]

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

@@ -1,6 +1,6 @@
-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 '../../src/facade/collection';
+import {isPresent, isArray} from '../../src/facade/lang';
 import * as modelModule from './model';
 import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
 

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

@@ -1,7 +1,7 @@
-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 {isPresent, isBlank, normalizeBool} from '../../src/facade/lang';
+import {Observable, EventEmitter, ObservableWrapper} from '../../src/facade/async';
+import {PromiseWrapper} from '../../src/facade/promise';
+import {StringMapWrapper, ListWrapper} from '../../src/facade/collection';
 import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
 
 /**

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

@@ -1,9 +1,9 @@
-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 {isBlank, isPresent, isString} from '../../src/facade/lang';
+import {PromiseWrapper} from '../../src/facade/promise';
+import {ObservableWrapper} from '../../src/facade/async';
+import {StringMapWrapper} from '../../src/facade/collection';
 import * as modelModule from './model';
 import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
 
@@ -16,7 +16,7 @@ import {ValidatorFn, AsyncValidatorFn} from './directives/validators';
  *
  * {@example core/forms/ts/ng_validators/ng_validators.ts region='ng_validators'}
  */
-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
@@ -26,7 +26,8 @@ export const NG_VALIDATORS: OpaqueToken = CONST_EXPR(new OpaqueToken("NgValidato
  *
  * See {@link NG_VALIDATORS} for more details.
  */
-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.

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,10 @@
-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 {Injectable, Inject, Optional} from '@angular/core';
+import {isPresent} from '../../src/facade/lang';
+
+import {LocationStrategy, APP_BASE_HREF} from './location_strategy';
+import {Location} from './location';
+import {UrlChangeListener, PlatformLocation} from './platform_location';
+
 
 /**
  * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
@@ -21,15 +18,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([
@@ -78,12 +77,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 +90,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,7 @@
+import {Injectable, Inject} from '@angular/core';
+import {EventEmitter, ObservableWrapper} from '../../src/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 +22,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([
@@ -51,7 +52,7 @@ export class Location {
 
   constructor(public platformStrategy: LocationStrategy) {
     var browserBaseHref = this.platformStrategy.getBaseHref();
-    this._baseHref = stripTrailingSlash(stripIndexHtml(browserBaseHref));
+    this._baseHref = Location.stripTrailingSlash(_stripIndexHtml(browserBaseHref));
     this.platformStrategy.onPopState((ev) => {
       ObservableWrapper.callEmit(this._subject, {'url': this.path(), 'pop': true, 'type': ev.type});
     });
@@ -67,7 +68,7 @@ export class Location {
    * trailing slashes
    */
   normalize(url: string): string {
-    return stripTrailingSlash(_stripBaseHref(this._baseHref, stripIndexHtml(url)));
+    return Location.stripTrailingSlash(_stripBaseHref(this._baseHref, _stripIndexHtml(url)));
   }
 
   /**
@@ -117,6 +118,50 @@ export class Location {
             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 +171,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';
 
 /**
@@ -41,8 +40,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([
@@ -58,31 +58,4 @@ export abstract class LocationStrategy {
  * ]);
  * ```
  */
-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,13 +1,10 @@
-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 {Injectable, Inject, Optional} from '@angular/core';
+import {isBlank} from '../../src/facade/lang';
+import {BaseException} from '../../src/facade/exceptions';
+
 import {PlatformLocation, UrlChangeListener} from './platform_location';
+import {LocationStrategy, APP_BASE_HREF} from './location_strategy';
+import {Location} from './location';
 
 /**
  * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
@@ -29,14 +26,17 @@ import {PlatformLocation, UrlChangeListener} from './platform_location';
  * ### Example
  *
  * ```
- * import {Component, provide} from 'angular2/core';
+ * import {Component, provide} 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([
@@ -81,19 +81,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/pipes/async_pipe.ts

@@ -1,13 +1,7 @@
-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 {Pipe, Injectable, ChangeDetectorRef, OnDestroy, WrappedValue} from '@angular/core';
+
+import {isBlank, isPresent, isPromise} from '../../src/facade/lang';
+import {ObservableWrapper, Observable, EventEmitter} from '../../src/facade/async';
 
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -55,7 +49,7 @@ var __unused: Promise<any>;  // avoid unused import when Promise union types are
  */
 @Pipe({name: 'async', pure: false})
 @Injectable()
-export class AsyncPipe implements PipeTransform, OnDestroy {
+export class AsyncPipe implements OnDestroy {
   /** @internal */
   _latestValue: Object = null;
   /** @internal */
@@ -76,7 +70,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

@@ -13,7 +13,6 @@ 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';
 
 /**
  * A collection of Angular core pipes that are likely to be used in each and every
@@ -22,7 +21,7 @@ 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.
  */
-export const COMMON_PIPES = CONST_EXPR([
+export const COMMON_PIPES = /*@ts2dart_const*/[
   AsyncPipe,
   UpperCasePipe,
   LowerCasePipe,
@@ -35,4 +34,4 @@ export const COMMON_PIPES = CONST_EXPR([
   ReplacePipe,
   I18nPluralPipe,
   I18nSelectPipe
-]);
+];

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

@@ -1,16 +1,12 @@
+import {PipeTransform, Pipe, Injectable} from '@angular/core';
 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';
+} from '../../src/facade/lang';
+import {DateFormatter} from '../../src/facade/intl';
+import {StringMapWrapper} from '../../src/facade/collection';
 
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -84,7 +80,6 @@ var defaultLocale: string = 'en-US';
  *
  * {@example core/pipes/ts/date_pipe/date_pipe_example.ts region='DatePipe'}
  */
-@CONST()
 @Pipe({name: 'date', pure: true})
 @Injectable()
 export class DatePipe implements PipeTransform {
@@ -101,14 +96,13 @@ 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);
     }

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

@@ -1,11 +1,5 @@
-import {
-  CONST,
-  isStringMap,
-  StringWrapper,
-  isPresent,
-  RegExpWrapper
-} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {Injectable, PipeTransform, Pipe} from '@angular/core';
+import {isStringMap, StringWrapper, isPresent, RegExpWrapper} from '../../src/facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 var interpolationExp: RegExp = RegExpWrapper.create('#');
@@ -41,14 +35,12 @@ var interpolationExp: RegExp = RegExpWrapper.create('#');
  *  ```
  *
  */
-@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);

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

@@ -1,6 +1,6 @@
-import {CONST, isStringMap} from 'angular2/src/facade/lang';
-import {StringMapWrapper} from 'angular2/src/facade/collection';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {Injectable, PipeTransform, Pipe} from '@angular/core';
+import {isStringMap} from '../../src/facade/lang';
+import {StringMapWrapper} from '../../src/facade/collection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -32,12 +32,10 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  *  }
  *  ```
  */
-@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 {Type, stringify} from '../../src/facade/lang';
+import {BaseException} from '../../src/facade/exceptions';
 
 export class InvalidPipeArgumentException extends BaseException {
   constructor(type: Type, value: Object) {

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

@@ -1,5 +1,6 @@
-import {isBlank, isPresent, Json, CONST} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from '@angular/core';
+import {Json} from '../../src/facade/lang';
+
 
 /**
  * Transforms any input value using `JSON.stringify`. Useful for debugging.
@@ -7,9 +8,9 @@ import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
  * ### Example
  * {@example core/pipes/ts/json_pipe/json_pipe_example.ts region='JsonPipe'}
  */
-@CONST()
+/* @ts2dart_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,5 +1,5 @@
-import {isString, CONST, isBlank} from 'angular2/src/facade/lang';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from '@angular/core';
+import {isString, isBlank} from '../../src/facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -9,11 +9,11 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  *
  * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
  */
-@CONST()
+/* @ts2dart_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

@@ -1,17 +1,15 @@
+import {Injectable, PipeTransform, WrappedValue, Pipe} from '@angular/core';
+
 import {
   isNumber,
   isPresent,
   isBlank,
-  StringWrapper,
   NumberWrapper,
   RegExpWrapper,
-  CONST,
-  FunctionWrapper
-} from 'angular2/src/facade/lang';
-import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
-import {NumberFormatter, NumberFormatStyle} from 'angular2/src/facade/intl';
-import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
-import {ListWrapper} from 'angular2/src/facade/collection';
+} from '../../src/facade/lang';
+import {BaseException} from '../../src/facade/exceptions';
+import {NumberFormatter, NumberFormatStyle} from '../../src/facade/intl';
+import {ListWrapper} from '../../src/facade/collection';
 
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -21,7 +19,6 @@ var _re = RegExpWrapper.create('^(\\d+)?\\.((\\d+)(\\-(\\d+))?)?$');
 /**
  * Internal base class for numeric pipes.
  */
-@CONST()
 @Injectable()
 export class NumberPipe {
   /** @internal */
@@ -83,12 +80,10 @@ export class NumberPipe {
  *
  * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='NumberPipe'}
  */
-@CONST()
 @Pipe({name: 'number'})
 @Injectable()
 export class DecimalPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var digits: string = ListWrapper.first(args);
+  transform(value: any, digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Decimal, digits);
   }
 }
@@ -109,12 +104,10 @@ export class DecimalPipe extends NumberPipe implements PipeTransform {
  *
  * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='PercentPipe'}
  */
-@CONST()
 @Pipe({name: 'percent'})
 @Injectable()
 export class PercentPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var digits: string = ListWrapper.first(args);
+  transform(value: any, digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Percent, digits);
   }
 }
@@ -139,14 +132,11 @@ export class PercentPipe extends NumberPipe implements PipeTransform {
  *
  * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='CurrencyPipe'}
  */
-@CONST()
 @Pipe({name: 'currency'})
 @Injectable()
 export class CurrencyPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var currencyCode: string = isPresent(args) && args.length > 0 ? args[0] : 'USD';
-    var symbolDisplay: boolean = isPresent(args) && args.length > 1 ? args[1] : false;
-    var digits: string = isPresent(args) && args.length > 2 ? args[2] : null;
+  transform(value: any, currencyCode: string = 'USD', symbolDisplay: boolean = false,
+            digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Currency, digits, currencyCode,
                               symbolDisplay);
   }

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

@@ -1,3 +1,5 @@
+import {Injectable, PipeTransform, Pipe} from '@angular/core';
+
 import {
   isBlank,
   isString,
@@ -5,9 +7,8 @@ import {
   isFunction,
   RegExpWrapper,
   StringWrapper
-} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
-import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+} from '../../src/facade/lang';
+
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -39,11 +40,7 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @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 +50,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);
@@ -67,16 +61,16 @@ export class ReplacePipe implements PipeTransform {
     // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
 
     if (isFunction(replacement)) {
-      var rgxPattern = isString(pattern) ? RegExpWrapper.create(pattern) : pattern;
+      var rgxPattern = isString(pattern) ? RegExpWrapper.create(<string>pattern) : <RegExp>pattern;
 
-      return StringWrapper.replaceAllMapped(input, rgxPattern, replacement);
+      return StringWrapper.replaceAllMapped(input, rgxPattern, <Function>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,9 @@
-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 {Injectable, PipeTransform, WrappedValue, Pipe} from '@angular/core';
+
+import {isBlank, isString, isArray, StringWrapper} from '../../src/facade/lang';
+import {BaseException} from '../../src/facade/exceptions';
+import {ListWrapper} from '../../src/facade/collection';
+
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -59,16 +61,11 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @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 (!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 {PipeTransform, WrappedValue, Injectable, Pipe} from '@angular/core';
+import {isString, isBlank} from '../../src/facade/lang';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 /**
@@ -9,11 +9,10 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
  *
  * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
  */
-@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

@@ -1,25 +1,22 @@
 import {
-  ComponentFixture,
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   beforeEachProviders,
   ddescribe,
   xdescribe,
   describe,
-  el,
   expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
-import {ListWrapper, StringMapWrapper, SetWrapper} from 'angular2/src/facade/collection';
-import {Component, provide} from 'angular2/core';
-import {NgFor} from 'angular2/common';
-import {NgClass} from 'angular2/src/common/directives/ng_class';
+} 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, classes: string) {
+function detectChangesAndCheck(fixture: ComponentFixture<any>, classes: string) {
   fixture.detectChanges();
   expect(fixture.debugElement.children[0].nativeElement.className).toEqual(classes);
 }
@@ -27,23 +24,21 @@ function detectChangesAndCheck(fixture: ComponentFixture, classes: string) {
 export function main() {
   describe('binding to CSS class list', () => {
 
-    describe('viewpool support', () => {
-      it('should clean up when the directive is destroyed',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           var template = '<div *ngFor="var 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']];
+    it('should clean up when the directive is destroyed',
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         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');
+               detectChangesAndCheck(fixture, '1');
 
-                 async.done();
-               });
-         }));
-    });
+               async.done();
+             });
+       }));
 
 
     describe('expressions evaluating to objects', () => {

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

@@ -1,29 +1,28 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   beforeEachProviders,
   ddescribe,
   describe,
-  el,
-  expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
+} 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 'angular2/src/facade/collection';
-import {IS_DART} from 'angular2/src/facade/lang';
-import {Component, TemplateRef, ContentChild} from 'angular2/core';
-import {NgFor} from 'angular2/src/common/directives/ng_for';
-import {NgIf} from 'angular2/src/common/directives/ng_if';
-import {By} from 'angular2/platform/common_dom';
+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 #item of items">{{item.toString()}};</copy-me></div>';
+        '<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) => {
@@ -100,7 +99,7 @@ export function main() {
 
     it('should iterate over an array of objects',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = '<ul><li template="ngFor #item of items">{{item["name"]}};</li></ul>';
+         var template = '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
 
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -130,7 +129,7 @@ export function main() {
 
     it('should gracefully handle nulls',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = '<ul><li template="ngFor #item of null">{{item}};</li></ul>';
+         var template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -207,8 +206,8 @@ export function main() {
     it('should repeat over nested arrays',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          var template = '<div>' +
-                        '<div template="ngFor #item of items">' +
-                        '<div template="ngFor #subitem of item">' +
+                        '<div template="ngFor let item of items">' +
+                        '<div template="ngFor let subitem of item">' +
                         '{{subitem}}-{{item.length}};' +
                         '</div>|' +
                         '</div>' +
@@ -233,8 +232,8 @@ export function main() {
 
     it('should repeat over nested arrays with no intermediate element',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         var template = '<div><template ngFor #item [ngForOf]="items">' +
-                        '<div template="ngFor #subitem of item">' +
+         var template = '<div><template ngFor let-item [ngForOf]="items">' +
+                        '<div template="ngFor let subitem of item">' +
                         '{{subitem}}-{{item.length}};' +
                         '</div></template></div>';
 
@@ -255,7 +254,7 @@ export function main() {
     it('should repeat over nested ngIf that are the last node in the ngFor temlate',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          var template =
-             `<div><template ngFor #item [ngForOf]="items" #i="index"><div>{{i}}|</div>` +
+             `<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)
@@ -282,7 +281,7 @@ export function main() {
     it('should display indices correctly',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          var template =
-             '<div><copy-me template="ngFor: var item of items; var i=index">{{i.toString()}}</copy-me></div>';
+             '<div><copy-me template="ngFor: let item of items; let i=index">{{i.toString()}}</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -298,10 +297,29 @@ export function main() {
              });
        }));
 
+    it('should display first item correctly',
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         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) => {
          var template =
-             '<div><copy-me template="ngFor: var item of items; var isLast=last">{{isLast.toString()}}</copy-me></div>';
+             '<div><copy-me template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -320,7 +338,7 @@ export function main() {
     it('should display even items correctly',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          var template =
-             '<div><copy-me template="ngFor: var item of items; var isEven=even">{{isEven.toString()}}</copy-me></div>';
+             '<div><copy-me template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -339,7 +357,7 @@ export function main() {
     it('should display odd items correctly',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          var template =
-             '<div><copy-me template="ngFor: var item of items; var isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
+             '<div><copy-me template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -362,7 +380,7 @@ export function main() {
                 '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>')
              .overrideTemplate(
                  ComponentUsingTestComponent,
-                 '<test-cmp><li template="#item #i=index">{{i}}: {{item}};</li></test-cmp>')
+                 '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
              .createAsync(ComponentUsingTestComponent)
              .then((fixture) => {
                var testComponent = fixture.debugElement.children[0];
@@ -376,8 +394,8 @@ export function main() {
 
     it('should use a default template if a custom one is null',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideTemplate(TestComponent, `<ul><template ngFor #item [ngForOf]="items"
-         [ngForTemplate]="contentTpl" #i="index">{{i}}: {{item}};</template></ul>`)
+         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) => {
@@ -392,11 +410,11 @@ export function main() {
 
     it('should use a custom template when both default and a custom one are present',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideTemplate(TestComponent, `<ul><template ngFor #item [ngForOf]="items"
-         [ngForTemplate]="contentTpl" #i="index">{{i}}=> {{item}};</template></ul>`)
+         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="#item #i=index">{{i}}: {{item}};</li></test-cmp>')
+                 '<test-cmp><li template="let item; let i=index">{{i}}: {{item}};</li></test-cmp>')
              .createAsync(ComponentUsingTestComponent)
              .then((fixture) => {
                var testComponent = fixture.debugElement.children[0];
@@ -412,7 +430,7 @@ export function main() {
       it('should not replace tracked items',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            var template =
-               `<template ngFor #item [ngForOf]="items" [ngForTrackBy]="trackById" #i="index">
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
                <p>{{items[i]}}</p>
               </template>`;
            tcb.overrideTemplate(TestComponent, template)
@@ -434,7 +452,7 @@ export function main() {
       it('should update implicit local variable on view',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            var template =
-               `<div><template ngFor #item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
                .createAsync(TestComponent)
                .then((fixture) => {
@@ -450,7 +468,7 @@ export function main() {
       it('should move items around and keep them updated ',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            var template =
-               `<div><template ngFor #item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
                .createAsync(TestComponent)
                .then((fixture) => {
@@ -469,7 +487,7 @@ export function main() {
       it('should handle added and removed items properly when tracking by index',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            var template =
-               `<div><template ngFor #item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
+               `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
                .createAsync(TestComponent)
                .then((fixture) => {
@@ -493,7 +511,7 @@ class Foo {
 
 @Component({selector: 'test-cmp', directives: [NgFor, NgIf], template: ''})
 class TestComponent {
-  @ContentChild(TemplateRef) contentTpl: TemplateRef;
+  @ContentChild(TemplateRef) contentTpl: TemplateRef<Object>;
   items: any;
   constructor() { this.items = [1, 2]; }
   trackById(index: number, item: any): string { return item['id']; }

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

@@ -1,23 +1,22 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   ddescribe,
   describe,
-  el,
-  expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
+import {expect} from '@angular/platform-browser/testing';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
 
-import {DOM} from 'angular2/src/platform/dom/dom_adapter';
+import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 
-import {Component} from 'angular2/core';
-import {NgIf} from 'angular2/common';
+import {Component} from '@angular/core';
+import {NgIf} from '@angular/common';
 
-import {IS_DART} from 'angular2/src/facade/lang';
+import {IS_DART} from '../../src/facade/lang';
 
 export function main() {
   describe('ngIf directive', () => {
@@ -29,7 +28,8 @@ export function main() {
              .createAsync(TestComponent)
              .then((fixture) => {
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(1);
                expect(fixture.debugElement.nativeElement).toHaveText('hello');
                async.done();
@@ -45,7 +45,8 @@ export function main() {
              .createAsync(TestComponent)
              .then((fixture) => {
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(1);
                expect(fixture.debugElement.nativeElement).toHaveText('hello2');
                async.done();
@@ -61,19 +62,22 @@ export function main() {
              .then((fixture) => {
                fixture.debugElement.componentInstance.booleanCondition = false;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(0);
                expect(fixture.debugElement.nativeElement).toHaveText('');
 
                fixture.debugElement.componentInstance.booleanCondition = true;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               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(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(0);
                expect(fixture.debugElement.nativeElement).toHaveText('');
 
@@ -91,31 +95,36 @@ export function main() {
              .then((fixture) => {
                fixture.debugElement.componentInstance.booleanCondition = false;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(0);
                expect(fixture.debugElement.nativeElement).toHaveText('');
 
                fixture.debugElement.componentInstance.booleanCondition = true;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               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(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(0);
                expect(fixture.debugElement.nativeElement).toHaveText('');
 
                fixture.debugElement.componentInstance.nestedBooleanCondition = true;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               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(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(0);
                expect(fixture.debugElement.nativeElement).toHaveText('');
 
@@ -136,21 +145,24 @@ export function main() {
              .createAsync(TestComponent)
              .then((fixture) => {
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(3);
-               expect(DOM.getText(fixture.debugElement.nativeElement))
+               expect(getDOM().getText(fixture.debugElement.nativeElement))
                    .toEqual('helloNumberhelloStringhelloFunction');
 
                fixture.debugElement.componentInstance.numberCondition = 0;
                fixture.detectChanges();
-               expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               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(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+               expect(
+                   getDOM().querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
                    .toEqual(1);
                expect(fixture.debugElement.nativeElement).toHaveText('helloNumber');
                async.done();
@@ -167,13 +179,17 @@ export function main() {
                .createAsync(TestComponent)
                .then((fixture) => {
                  fixture.detectChanges();
-                 expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+                 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(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+                 expect(getDOM()
+                            .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                            .length)
                      .toEqual(1);
                  expect(fixture.debugElement.nativeElement).toHaveText('hello');
 
@@ -189,14 +205,14 @@ export function main() {
                .createAsync(TestComponent)
                .then((fixture) => {
                  fixture.detectChanges();
-                 DOM.addClass(DOM.querySelector(fixture.debugElement.nativeElement, 'copy-me'),
-                              "foo");
+                 getDOM().addClass(
+                     getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'), "foo");
 
                  fixture.debugElement.componentInstance.numberCondition = 2;
                  fixture.detectChanges();
-                 expect(
-                     DOM.hasClass(DOM.querySelector(fixture.debugElement.nativeElement, 'copy-me'),
-                                  "foo"))
+                 expect(getDOM().hasClass(
+                            getDOM().querySelector(fixture.debugElement.nativeElement, 'copy-me'),
+                            "foo"))
                      .toBe(true);
 
                  async.done();
@@ -213,7 +229,9 @@ export function main() {
                .createAsync(TestComponent)
                .then((fixture) => {
                  expect(() => fixture.detectChanges()).toThrowError();
-                 expect(DOM.querySelectorAll(fixture.debugElement.nativeElement, 'copy-me').length)
+                 expect(getDOM()
+                            .querySelectorAll(fixture.debugElement.nativeElement, 'copy-me')
+                            .length)
                      .toEqual(0);
                  expect(fixture.debugElement.nativeElement).toHaveText('');
                  async.done();

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

@@ -1,20 +1,19 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEachProviders,
   beforeEach,
   ddescribe,
   describe,
-  el,
   expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
 
-import {Component, Injectable, provide} from 'angular2/core';
-import {NgPlural, NgPluralCase, NgLocalization} from 'angular2/common';
+import {Component, Injectable, provide} from '@angular/core';
+import {NgPlural, NgPluralCase, NgLocalization} from '@angular/common';
 
 export function main() {
   describe('switch', () => {

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

@@ -1,25 +1,24 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   beforeEachProviders,
   ddescribe,
   xdescribe,
   describe,
-  el,
   expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
 
-import {StringMapWrapper} from 'angular2/src/facade/collection';
+import {StringMapWrapper} from '../../src/facade/collection';
 
-import {Component} from 'angular2/core';
+import {Component} from '@angular/core';
 
-import {DOM} from 'angular2/src/platform/dom/dom_adapter';
-import {NgStyle} from 'angular2/src/common/directives/ng_style';
+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', () => {
@@ -32,7 +31,8 @@ export function main() {
              .createAsync(TestComponent)
              .then((fixture) => {
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('40px');
 
                async.done();
@@ -50,13 +50,15 @@ export function main() {
 
                fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('40px');
 
                expr = fixture.debugElement.componentInstance.expr;
                expr['max-width'] = '30%';
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('30%');
 
                async.done();
@@ -72,12 +74,14 @@ export function main() {
              .then((fixture) => {
                fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('40px');
 
                StringMapWrapper.delete(fixture.debugElement.componentInstance.expr, 'max-width');
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('');
 
                async.done();
@@ -93,16 +97,20 @@ export function main() {
              .then((fixture) => {
                fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('40px');
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
                    .toEqual('12px');
 
                StringMapWrapper.delete(fixture.debugElement.componentInstance.expr, 'max-width');
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('');
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
                    .toEqual('12px');
 
                async.done();
@@ -118,17 +126,21 @@ export function main() {
              .then((fixture) => {
                fixture.debugElement.componentInstance.expr = {'max-width': '40px'};
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('40px');
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
                    .toEqual('12px');
 
                StringMapWrapper.delete(fixture.debugElement.componentInstance.expr, 'max-width');
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'font-size'))
                    .toEqual('12px');
 
                fixture.detectChanges();
-               expect(DOM.getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
+               expect(
+                   getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
                    .toEqual('');
 
                async.done();

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

@@ -1,20 +1,18 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   ddescribe,
   describe,
-  el,
   expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
+} 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 {Component} from 'angular2/core';
-
-import {NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/src/common/directives/ng_switch';
+import {NgSwitch, NgSwitchWhen, NgSwitchDefault} from '@angular/common';
 
 export function main() {
   describe('switch', () => {

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

@@ -0,0 +1,110 @@
+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) => {
+         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) => {
+         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) => {
+         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) => {
+         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();
+             });
+       }));
+
+  });
+}
+
+
+@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>;
+}

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

@@ -1,19 +1,18 @@
 import {
-  AsyncTestCompleter,
-  TestComponentBuilder,
   beforeEach,
   ddescribe,
   describe,
-  el,
   expect,
   iit,
   inject,
   it,
   xit,
-} from 'angular2/testing_internal';
-import {DOM} from 'angular2/src/platform/dom/dom_adapter';
-import {Component, Directive} from 'angular2/core';
-import {ElementRef} from 'angular2/src/core/linker/element_ref';
+} 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', () => {
@@ -37,10 +36,10 @@ export function main() {
              .then((fixture) => {
                fixture.detectChanges();
 
-               // We must use DOM.querySelector instead of fixture.query here
+               // We must use getDOM().querySelector instead of fixture.query here
                // since the elements inside are not compiled.
-               var span = DOM.querySelector(fixture.debugElement.nativeElement, '#child');
-               expect(DOM.hasClass(span, 'compiled')).toBeFalsy();
+               var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+               expect(getDOM().hasClass(span, 'compiled')).toBeFalsy();
                async.done();
              });
        }));
@@ -52,8 +51,8 @@ export function main() {
              .createAsync(TestComponent)
              .then((fixture) => {
                fixture.detectChanges();
-               var span = DOM.querySelector(fixture.debugElement.nativeElement, '#child');
-               expect(DOM.hasClass(span, 'compiled')).toBeTruthy();
+               var span = getDOM().querySelector(fixture.debugElement.nativeElement, '#child');
+               expect(getDOM().hasClass(span, 'compiled')).toBeTruthy();
                async.done();
              });
        }));
@@ -62,7 +61,7 @@ export function main() {
 
 @Directive({selector: '[test-dec]'})
 class TestDirective {
-  constructor(el: ElementRef) { DOM.addClass(el.nativeElement, 'compiled'); }
+  constructor(el: ElementRef) { getDOM().addClass(el.nativeElement, 'compiled'); }
 }
 
 @Component({selector: 'test-cmp', directives: [TestDirective], template: ''})

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

@@ -1,24 +1,24 @@
 import {
   ddescribe,
   describe,
-  fakeAsync,
-  flushMicrotasks,
   it,
   iit,
   xit,
   expect,
   beforeEach,
   afterEach,
-  el,
-  AsyncTestCompleter,
-  inject,
-  tick
-} from 'angular2/testing_internal';
+  inject
+} 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,
@@ -35,13 +35,13 @@ import {
   CheckboxControlValueAccessor,
   SelectControlValueAccessor,
   Validator
-} from 'angular2/common';
+} from '@angular/common';
 
 
-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/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;
@@ -71,7 +71,7 @@ function asyncValidator(expected, timeout = 0) {
 
 export function main() {
   describe("Form Directives", () => {
-    var defaultAccessor;
+    var defaultAccessor: DefaultValueAccessor;
 
     beforeEach(() => { defaultAccessor = new DefaultValueAccessor(null, null); });
 
@@ -108,7 +108,7 @@ export function main() {
         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);
         });
 

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

@@ -6,11 +6,10 @@ import {
   xit,
   expect,
   beforeEach,
-  afterEach,
-  el
-} from 'angular2/testing_internal';
-import {Control, FormBuilder} from 'angular2/common';
-import {PromiseWrapper} from 'angular2/src/facade/promise';
+  afterEach
+} from '@angular/core/testing/testing_internal';
+import {Control, FormBuilder} from '@angular/common';
+import {PromiseWrapper} from '../../src/facade/promise';
 
 export function main() {
   function syncValidator(_) { return null; }

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

@@ -7,19 +7,17 @@ import {
   expect,
   beforeEach,
   afterEach,
-  el,
-  AsyncTestCompleter,
-  fakeAsync,
-  tick,
-  inject
-} from 'angular2/testing_internal';
-import {ControlGroup, Control, ControlArray, Validators} from 'angular2/common';
-import {IS_DART, isPresent, CONST_EXPR} from 'angular2/src/facade/lang';
-import {PromiseWrapper} from 'angular2/src/facade/promise';
-import {TimerWrapper, ObservableWrapper, EventEmitter} from 'angular2/src/facade/async';
+  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';
+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, timeouts = CONST_EXPR({})) {
+  function asyncValidator(expected, timeouts = /*@ts2dart_const*/ {}) {
     return (c) => {
       var completer = PromiseWrapper.completer();
       var t = isPresent(timeouts[c.value]) ? timeouts[c.value] : 0;

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

@@ -6,15 +6,12 @@ import {
   xit,
   expect,
   beforeEach,
-  afterEach,
-  fakeAsync,
-  tick,
-  el
-} from 'angular2/testing_internal';
-import {ControlGroup, Control, Validators, AbstractControl, ControlArray} from 'angular2/common';
-import {PromiseWrapper} from 'angular2/src/facade/promise';
-import {EventEmitter, ObservableWrapper, TimerWrapper} from 'angular2/src/facade/async';
-import {CONST_EXPR} from 'angular2/src/facade/lang';
+  afterEach
+} from '@angular/core/testing/testing_internal';
+import {fakeAsync, flushMicrotasks, Log, tick} from '@angular/core/testing';
+import {ControlGroup, Control, Validators, AbstractControl, ControlArray} from '@angular/common';
+import {PromiseWrapper} from '../../src/facade/promise';
+import {EventEmitter, ObservableWrapper, TimerWrapper} from '../../src/facade/async';
 
 export function main() {
   function validator(key: string, error: any) {

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

@@ -7,23 +7,22 @@ import {
   expect,
   beforeEach,
   afterEach,
-  AsyncTestCompleter,
   inject,
-  browserDetection
-} from 'angular2/testing_internal';
+} 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 {isBlank} from '../../src/facade/lang';
+import {AsyncPipe} from '@angular/common';
+import {WrappedValue} from '@angular/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';
+} 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", () => {
@@ -121,7 +120,7 @@ export function main() {
       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();
@@ -208,14 +207,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,82 @@
+import {
+  ddescribe,
+  describe,
+  it,
+  iit,
+  xit,
+  expect,
+  beforeEach,
+  afterEach
+} from '@angular/core/testing/testing_internal';
+import {browserDetection} from '@angular/platform-browser/testing';
+
+import {DatePipe} from '@angular/common';
+import {DateWrapper} from '../../src/facade/lang';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
+
+export function main() {
+  describe("DatePipe", () => {
+    var date;
+    var pipe;
+
+    beforeEach(() => {
+      date = DateWrapper.create(2015, 6, 15, 21, 43, 11);
+      pipe = new DatePipe();
+    });
+
+    it('should be marked as pure',
+       () => { expect(new PipeResolver().resolve(DatePipe).pure).toEqual(true); });
+
+    describe("supports", () => {
+      it("should support date", () => { expect(pipe.supports(date)).toBe(true); });
+      it("should support int", () => { expect(pipe.supports(123456789)).toBe(true); });
+
+      it("should not support other objects", () => {
+        expect(pipe.supports(new Object())).toBe(false);
+        expect(pipe.supports(null)).toBe(false);
+      });
+    });
+
+    // TODO(mlaval): enable tests when Intl API is no longer used, see
+    // https://github.com/angular/angular/issues/3333
+    if (browserDetection.supportsIntlApi) {
+      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('43');
+          expect(pipe.transform(date, 's')).toEqual('11');
+        });
+
+        it('should format common multi component patterns', () => {
+          expect(pipe.transform(date, 'yMEd')).toEqual('Mon, 6/15/2015');
+          expect(pipe.transform(date, 'MEd')).toEqual('Mon, 6/15');
+          expect(pipe.transform(date, 'MMMd')).toEqual('Jun 15');
+          expect(pipe.transform(date, 'yMMMMEEEEd')).toEqual('Monday, June 15, 2015');
+          expect(pipe.transform(date, 'jms')).toEqual('9:43:11 PM');
+          expect(pipe.transform(date, 'ms')).toEqual('43:11');
+        });
+
+        it('should format with pattern aliases', () => {
+          expect(pipe.transform(date, 'medium')).toEqual('Jun 15, 2015, 9:43:11 PM');
+          expect(pipe.transform(date, 'short')).toEqual('6/15/2015, 9:43 PM');
+          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:43:11 PM');
+          expect(pipe.transform(date, 'shortTime')).toEqual('9:43 PM');
+        });
+      });
+    }
+  });
+}

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

@@ -7,10 +7,10 @@ import {
   expect,
   beforeEach,
   afterEach
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
 
-import {I18nPluralPipe} from 'angular2/common';
-import {PipeResolver} from 'angular2/src/core/linker/pipe_resolver';
+import {I18nPluralPipe} from '@angular/common';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
 
 export function main() {
   describe("I18nPluralPipe", () => {
@@ -26,33 +26,33 @@ export function main() {
 
     describe("transform", () => {
       it("should return 0 text if value is 0", () => {
-        var val = pipe.transform(0, [mapping]);
+        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]);
+        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]);
+        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]);
+        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 messageLength;
-        var val = pipe.transform(messageLength, [interpolatedMapping]);
+        var val = pipe.transform(messageLength, interpolatedMapping);
         expect(val).toEqual('There are  messages, that is .');
       });
 
       it("should not support bad arguments",
-         () => { expect(() => pipe.transform(0, ['hey'])).toThrowError(); });
+         () => { expect(() => pipe.transform(0, 'hey')).toThrowError(); });
     });
 
   });

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

@@ -7,10 +7,10 @@ import {
   expect,
   beforeEach,
   afterEach
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
 
-import {I18nSelectPipe} from 'angular2/common';
-import {PipeResolver} from 'angular2/src/core/linker/pipe_resolver';
+import {I18nSelectPipe} from '@angular/common';
+import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
 
 export function main() {
   describe("I18nSelectPipe", () => {
@@ -24,28 +24,28 @@ export function main() {
 
     describe("transform", () => {
       it("should return male text if value is male", () => {
-        var val = pipe.transform('male', [mapping]);
+        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]);
+        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]);
+        var val = pipe.transform('Anything else', mapping);
         expect(val).toEqual('Invite them.');
       });
 
       it("should use 'other' if value is undefined", () => {
         var gender;
-        var val = pipe.transform(gender, [mapping]);
+        var val = pipe.transform(gender, mapping);
         expect(val).toEqual('Invite them.');
       });
 
       it("should not support bad arguments",
-         () => { expect(() => pipe.transform('male', ['hey'])).toThrowError(); });
+         () => { expect(() => pipe.transform('male', 'hey')).toThrowError(); });
     });
 
   });

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

@@ -7,15 +7,14 @@ import {
   expect,
   beforeEach,
   afterEach,
-  AsyncTestCompleter,
   inject,
-  proxy,
-  TestComponentBuilder
-} from 'angular2/testing_internal';
-import {Json, RegExp, NumberWrapper, StringWrapper} from 'angular2/src/facade/lang';
+} from '@angular/core/testing/testing_internal';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {Json, RegExp, NumberWrapper, StringWrapper} from '../../src/facade/lang';
 
-import {Component} from 'angular2/core';
-import {JsonPipe} from 'angular2/common';
+import {Component} from '@angular/core';
+import {JsonPipe} from '@angular/common';
 
 export function main() {
   describe("JsonPipe", () => {

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

@@ -7,9 +7,9 @@ import {
   expect,
   beforeEach,
   afterEach
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
 
-import {LowerCasePipe} from 'angular2/common';
+import {LowerCasePipe} from '@angular/common';
 
 export function main() {
   describe("LowerCasePipe", () => {

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

@@ -7,10 +7,10 @@ import {
   expect,
   beforeEach,
   afterEach,
-  browserDetection
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
+import {browserDetection} from '@angular/platform-browser/testing';
 
-import {DecimalPipe, PercentPipe, CurrencyPipe} from 'angular2/common';
+import {DecimalPipe, PercentPipe, CurrencyPipe} from '@angular/common';
 
 export function main() {
   describe('Number pipes', () => {
@@ -24,17 +24,17 @@ export function main() {
 
         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(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');
+            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(); });
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
         });
       });
 
@@ -45,12 +45,12 @@ export function main() {
 
         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%');
+            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(); });
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
         });
       });
 
@@ -61,12 +61,12 @@ export function main() {
 
         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(123)).toEqual('USD123');
+            expect(pipe.transform(12, 'EUR', false, '.2')).toEqual('EUR12.00');
           });
 
           it("should not support other objects",
-             () => { expect(() => pipe.transform(new Object(), [])).toThrowError(); });
+             () => { expect(() => pipe.transform(new Object())).toThrowError(); });
         });
       });
     }

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

@@ -0,0 +1,71 @@
+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 {ReplacePipe} from '@angular/common';
+import {RegExpWrapper, StringJoiner} from '../../src/facade/lang';
+
+export function main() {
+  describe("ReplacePipe", () => {
+    var someNumber: number;
+    var str;
+    var pipe;
+
+    beforeEach(() => {
+      someNumber = 42;
+      str = 'Douglas Adams';
+      pipe = new ReplacePipe();
+    });
+
+    describe("transform", () => {
+
+      it("should not support input other than strings and numbers", () => {
+        expect(() => pipe.transform({}, "Douglas", "Hugh")).toThrow();
+        expect(() => pipe.transform([1, 2, 3], "Douglas", "Hugh")).toThrow();
+      });
+
+      it("should not support patterns other than strings and regular expressions", () => {
+        expect(() => pipe.transform(str, {}, "Hugh")).toThrow();
+        expect(() => pipe.transform(str, null, "Hugh")).toThrow();
+        expect(() => pipe.transform(str, 123, "Hugh")).toThrow();
+      });
+
+      it("should not support replacements other than strings and functions", () => {
+        expect(() => pipe.transform(str, "Douglas", {})).toThrow();
+        expect(() => pipe.transform(str, "Douglas", null)).toThrow();
+        expect(() => pipe.transform(str, "Douglas", 123)).toThrow();
+      });
+
+      it("should return a new string with the pattern replaced", () => {
+        var result1 = pipe.transform(str, "Douglas", "Hugh");
+
+        var result2 = pipe.transform(str, RegExpWrapper.create("a"), "_");
+
+        var result3 = pipe.transform(str, RegExpWrapper.create("a", "i"), "_");
+
+        var f = (x => { return "Adams!"; });
+
+        var result4 = pipe.transform(str, "Adams", f);
+
+        var result5 = pipe.transform(someNumber, "2", "4");
+
+        expect(result1).toEqual("Hugh Adams");
+        expect(result2).toEqual("Dougl_s Ad_ms");
+        expect(result3).toEqual("Dougl_s _d_ms");
+        expect(result4).toEqual("Douglas Adams!");
+        expect(result5).toEqual("44");
+      });
+
+    });
+
+  });
+}

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

@@ -7,14 +7,15 @@ import {
   expect,
   beforeEach,
   afterEach,
-  browserDetection,
   inject,
-  TestComponentBuilder,
-  AsyncTestCompleter
-} from 'angular2/testing_internal';
+} from '@angular/core/testing/testing_internal';
+import {} from '@angular/core/testing/testing_internal';
+import {browserDetection} from '@angular/platform-browser/testing';
+import {TestComponentBuilder, ComponentFixture} from '@angular/compiler/testing';
+import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
 
-import {Component} from 'angular2/core';
-import {SlicePipe} from 'angular2/common';
+import {Component} from '@angular/core';
+import {SlicePipe} from '@angular/common';
 
 export function main() {
   describe("SlicePipe", () => {
@@ -42,47 +43,47 @@ export function main() {
 
       it('should return all items after START index when START is positive and END is omitted',
          () => {
-           expect(pipe.transform(list, [3])).toEqual([4, 5]);
-           expect(pipe.transform(str, [3])).toEqual('wxyz');
+           expect(pipe.transform(list, 3)).toEqual([4, 5]);
+           expect(pipe.transform(str, 3)).toEqual('wxyz');
          });
 
       it('should return last START items when START is negative and END is omitted', () => {
-        expect(pipe.transform(list, [-3])).toEqual([3, 4, 5]);
-        expect(pipe.transform(str, [-3])).toEqual('xyz');
+        expect(pipe.transform(list, -3)).toEqual([3, 4, 5]);
+        expect(pipe.transform(str, -3)).toEqual('xyz');
       });
 
       it('should return all items between START and END index when START and END are positive',
          () => {
-           expect(pipe.transform(list, [1, 3])).toEqual([2, 3]);
-           expect(pipe.transform(str, [1, 3])).toEqual('uv');
+           expect(pipe.transform(list, 1, 3)).toEqual([2, 3]);
+           expect(pipe.transform(str, 1, 3)).toEqual('uv');
          });
 
       it('should return all items between START and END from the end when START and END are negative',
          () => {
-           expect(pipe.transform(list, [-4, -2])).toEqual([2, 3]);
-           expect(pipe.transform(str, [-4, -2])).toEqual('wx');
+           expect(pipe.transform(list, -4, -2)).toEqual([2, 3]);
+           expect(pipe.transform(str, -4, -2)).toEqual('wx');
          });
 
       it('should return an empty value if START is greater than END', () => {
-        expect(pipe.transform(list, [4, 2])).toEqual([]);
-        expect(pipe.transform(str, [4, 2])).toEqual('');
+        expect(pipe.transform(list, 4, 2)).toEqual([]);
+        expect(pipe.transform(str, 4, 2)).toEqual('');
       });
 
       it('should return an empty value if START greater than input length', () => {
-        expect(pipe.transform(list, [99])).toEqual([]);
-        expect(pipe.transform(str, [99])).toEqual('');
+        expect(pipe.transform(list, 99)).toEqual([]);
+        expect(pipe.transform(str, 99)).toEqual('');
       });
 
       // Makes Edge to disconnect when running the full unit test campaign
       // TODO: remove when issue is solved: https://github.com/angular/angular/issues/4756
       if (!browserDetection.isEdge) {
         it('should return entire input if START is negative and greater than input length', () => {
-          expect(pipe.transform(list, [-99])).toEqual([1, 2, 3, 4, 5]);
-          expect(pipe.transform(str, [-99])).toEqual('tuvwxyz');
+          expect(pipe.transform(list, -99)).toEqual([1, 2, 3, 4, 5]);
+          expect(pipe.transform(str, -99)).toEqual('tuvwxyz');
         });
 
         it('should not modify the input list', () => {
-          expect(pipe.transform(list, [2])).toEqual([3, 4, 5]);
+          expect(pipe.transform(list, 2)).toEqual([3, 4, 5]);
           expect(list).toEqual([1, 2, 3, 4, 5]);
         });
       }

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

@@ -7,9 +7,8 @@ import {
   expect,
   beforeEach,
   afterEach
-} from 'angular2/testing_internal';
-
-import {UpperCasePipe} from 'angular2/common';
+} from '@angular/core/testing/testing_internal';
+import {UpperCasePipe} from '@angular/common';
 
 export function main() {
   describe("UpperCasePipe", () => {

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

@@ -1,5 +1,5 @@
-import {ChangeDetectorRef} from 'angular2/src/core/change_detection/change_detector_ref';
-import {SpyObject, proxy} from 'angular2/testing_internal';
+import {ChangeDetectorRef} from '@angular/core/src/change_detection/change_detector_ref';
+import {SpyObject, proxy} from '@angular/core/testing/testing_internal';
 
 export class SpyChangeDetectorRef extends SpyObject {
   constructor() {
@@ -10,4 +10,4 @@ export class SpyChangeDetectorRef extends SpyObject {
 
 export class SpyNgControl extends SpyObject {}
 
-export class SpyValueAccessor extends SpyObject {}
+export class SpyValueAccessor extends SpyObject { writeValue: any; }

modules/@angular/common/testing.ts

@@ -0,0 +1,2 @@
+export {MockLocationStrategy} from './testing/mock_location_strategy';
+export {SpyLocation} from './testing/location_mock';

modules/@angular/common/testing/location_mock.ts

@@ -1,7 +1,6 @@
-import {Injectable} from 'angular2/src/core/di';
-import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
-import {ListWrapper} from 'angular2/src/facade/collection';
-import {Location} from 'angular2/src/router/location/location';
+import {Injectable, EventEmitter} from '@angular/core';
+import {ObservableWrapper} from '../src/facade/async';
+import {Location} from '../index';
 
 /**
  * A spy for {@link Location} that allows tests to fire simulated location events.