From 86fbd50c3d069667ee942b9fd53e7374dfec9733 Mon Sep 17 00:00:00 2001
From: ScottSWu <scott.wu.hjx@gmail.com>
Date: Wed, 8 Jun 2016 15:45:15 -0700
Subject: [PATCH] refactor(TypeScript): Add noImplicitAny

We automatically insert explicit 'any's where needed. These need to be
addressed as in #9100.

Fixes #4924
---
 .../@angular/common/src/directives/ng_for.ts  |   2 +-
 .../common/test/directives/ng_class_spec.ts   |  54 ++---
 .../common/test/directives/ng_for_spec.ts     |  52 ++---
 .../common/test/directives/ng_if_spec.ts      |  18 +-
 .../common/test/directives/ng_plural_spec.ts  |   8 +-
 .../common/test/directives/ng_style_spec.ts   |  14 +-
 .../common/test/directives/ng_switch_spec.ts  |   8 +-
 .../directives/ng_template_outlet_spec.ts     |   8 +-
 .../test/directives/non_bindable_spec.ts      |   6 +-
 .../test/forms-deprecated/directives_spec.ts  |  48 ++--
 .../forms-deprecated/form_builder_spec.ts     |   6 +-
 .../test/forms-deprecated/integration_spec.ts | 102 ++++-----
 .../test/forms-deprecated/model_spec.ts       |  66 +++---
 .../test/forms-deprecated/validators_spec.ts  |  12 +-
 .../common/test/pipes/async_pipe_spec.ts      |  26 +--
 .../common/test/pipes/date_pipe_spec.ts       |   4 +-
 .../test/pipes/i18n_plural_pipe_spec.ts       |   4 +-
 .../test/pipes/i18n_select_pipe_spec.ts       |   4 +-
 .../common/test/pipes/json_pipe_spec.ts       |   8 +-
 .../common/test/pipes/lowercase_pipe_spec.ts  |   6 +-
 .../common/test/pipes/number_pipe_spec.ts     |   6 +-
 .../common/test/pipes/replace_pipe_spec.ts    |   6 +-
 .../common/test/pipes/slice_pipe_spec.ts      |   6 +-
 .../common/test/pipes/uppercase_pipe_spec.ts  |   6 +-
 .../src/animation/animation_compiler.ts       |  20 +-
 .../src/animation/animation_parser.ts         |  40 ++--
 .../@angular/compiler/src/compile_metadata.ts |   4 +-
 modules/@angular/compiler/src/config.ts       |  10 +-
 modules/@angular/compiler/src/css/lexer.ts    |  10 +-
 modules/@angular/compiler/src/css/parser.ts   |  38 ++--
 .../src/directive_lifecycle_reflector.ts      |   2 +-
 .../compiler/src/directive_resolver.ts        |   6 +-
 .../compiler/src/expression_parser/ast.ts     |   2 +-
 .../compiler/src/expression_parser/lexer.ts   |   4 +-
 .../compiler/src/expression_parser/parser.ts  |  28 +--
 modules/@angular/compiler/src/html_ast.ts     |   2 +-
 modules/@angular/compiler/src/html_lexer.ts   |  24 +-
 modules/@angular/compiler/src/html_parser.ts  |   6 +-
 .../compiler/src/i18n/i18n_html_parser.ts     |   6 +-
 modules/@angular/compiler/src/i18n/shared.ts  |   4 +-
 .../compiler/src/i18n/xmb_serializer.ts       |   4 +-
 .../compiler/src/metadata_resolver.ts         |  28 +--
 .../@angular/compiler/src/offline_compiler.ts |   6 +-
 .../compiler/src/output/abstract_emitter.ts   |   8 +-
 .../src/output/abstract_js_emitter.ts         |   4 +-
 .../compiler/src/output/dart_emitter.ts       |  10 +-
 .../compiler/src/output/dart_imports.ts       |   2 +-
 .../compiler/src/output/js_emitter.ts         |   2 +-
 .../compiler/src/output/output_ast.ts         |   2 +-
 .../compiler/src/output/output_interpreter.ts |  26 +--
 .../compiler/src/output/output_jit.ts         |   2 +-
 .../compiler/src/output/ts_emitter.ts         |  10 +-
 .../@angular/compiler/src/provider_parser.ts  |   2 +-
 .../@angular/compiler/src/runtime_compiler.ts |   8 +-
 .../src/schema/dom_element_schema_registry.ts |   2 +-
 modules/@angular/compiler/src/selector.ts     |  14 +-
 modules/@angular/compiler/src/shadow_css.ts   |  24 +-
 .../@angular/compiler/src/style_compiler.ts   |   2 +-
 .../compiler/src/style_url_resolver.ts        |   4 +-
 modules/@angular/compiler/src/template_ast.ts |   2 +-
 .../@angular/compiler/src/template_parser.ts  |  26 +--
 .../compiler/src/template_preparser.ts        |   6 +-
 modules/@angular/compiler/src/url_resolver.ts |   2 +-
 modules/@angular/compiler/src/util.ts         |   6 +-
 .../src/view_compiler/compile_element.ts      |  18 +-
 .../src/view_compiler/compile_query.ts        |   2 +-
 .../src/view_compiler/event_binder.ts         |   4 +-
 .../src/view_compiler/expression_converter.ts |  10 +-
 .../src/view_compiler/property_binder.ts      |   2 +-
 .../compiler/src/view_compiler/util.ts        |   2 +-
 .../src/view_compiler/view_builder.ts         |  28 +--
 .../src/view_compiler/view_compiler.ts        |   4 +-
 .../test/animation/animation_compiler_spec.ts |   2 +-
 .../test/animation/animation_parser_spec.ts   |   6 +-
 .../@angular/compiler/test/css/lexer_spec.ts  |  16 +-
 .../@angular/compiler/test/css/parser_spec.ts |   6 +-
 .../compiler/test/css/visitor_spec.ts         |  10 +-
 .../compiler/test/directive_lifecycle_spec.ts |   2 +-
 .../test/directive_normalizer_spec.ts         |  16 +-
 .../compiler/test/directive_resolver_spec.ts  |  34 +--
 .../test/expression_parser/lexer_spec.ts      |  14 +-
 .../test/expression_parser/parser_spec.ts     |  14 +-
 .../test/i18n/i18n_html_parser_spec.ts        |   2 +-
 .../compiler/test/offline_compiler_spec.ts    |   2 +-
 .../test/output/output_emitter_spec.ts        |   8 +-
 .../test/output/output_emitter_util.ts        |   4 +-
 .../compiler/test/schema/schema_extractor.ts  |  18 +-
 .../@angular/compiler/test/selector_spec.ts   |   4 +-
 .../@angular/compiler/test/shadow_css_spec.ts |   8 +-
 .../compiler/test/style_url_resolver_spec.ts  |   2 +-
 .../compiler/test/template_parser_spec.ts     |  10 +-
 .../compiler/test/template_preparser_spec.ts  |   2 +-
 .../test/test_component_builder_spec.ts       |  46 ++--
 .../@angular/compiler/test/xhr_mock_spec.ts   |  16 +-
 .../testing/test_component_builder.ts         |  12 +-
 .../compiler/testing/view_resolver_mock.ts    |   2 +-
 modules/@angular/compiler/testing/xhr_mock.ts |   4 +-
 .../animation/active_animation_players_map.ts |   4 +-
 .../src/animation/animation_group_player.ts   |   2 +-
 .../core/src/animation/animation_player.ts    |   6 +-
 .../animation/animation_sequence_player.ts    |   2 +-
 .../src/animation/animation_style_util.ts     |  36 +--
 .../@angular/core/src/animation/metadata.ts   |   2 +-
 modules/@angular/core/src/application_ref.ts  |   8 +-
 .../@angular/core/src/application_tokens.ts   |   2 +-
 .../differs/default_iterable_differ.ts        |  32 +--
 .../differs/default_keyvalue_differ.ts        |  16 +-
 .../differs/iterable_differs.ts               |   2 +-
 .../differs/keyvalue_differs.ts               |   4 +-
 modules/@angular/core/src/di/metadata.ts      |   4 +-
 modules/@angular/core/src/di/provider.ts      |  16 +-
 .../core/src/di/reflective_exceptions.ts      |  16 +-
 .../core/src/di/reflective_injector.ts        |   4 +-
 .../core/src/di/reflective_provider.ts        |  22 +-
 .../core/src/linker/component_resolver.ts     |   2 +-
 .../@angular/core/src/linker/debug_context.ts |   4 +-
 modules/@angular/core/src/linker/element.ts   |   4 +-
 .../@angular/core/src/linker/query_list.ts    |   2 +-
 .../src/linker/systemjs_component_resolver.ts |   2 +-
 modules/@angular/core/src/linker/view.ts      |   8 +-
 modules/@angular/core/src/linker/view_ref.ts  |   4 +-
 .../@angular/core/src/linker/view_utils.ts    |  28 +--
 .../core/src/metadata/lifecycle_hooks.ts      |  16 +-
 modules/@angular/core/src/profile/wtf_impl.ts |   8 +-
 .../src/reflection/reflection_capabilities.ts |   8 +-
 modules/@angular/core/src/render/api.ts       |   8 +-
 modules/@angular/core/src/util/decorators.ts  |  18 +-
 .../@angular/core/src/zone/ng_zone_impl.ts    |   8 +-
 .../active_animations_players_map_spec.ts     |   4 +-
 .../animation/animation_group_player_spec.ts  |   2 +-
 .../animation/animation_integration_spec.ts   |  28 +--
 .../animation_sequence_player_spec.ts         |   2 +-
 .../animation/animation_style_util_spec.ts    |   6 +-
 .../core/test/application_ref_spec.ts         |  10 +-
 .../differs/default_iterable_differ_spec.ts   |  10 +-
 .../differs/default_keyvalue_differ_spec.ts   |  18 +-
 .../differs/iterable_differs_spec.ts          |   6 +-
 .../core/test/change_detection/iterable.ts    |   2 +-
 .../core/test/change_detection/util.ts        |   6 +-
 .../core/test/debug/debug_node_spec.ts        |  30 +--
 .../core/test/di/reflective_injector_spec.ts  |  22 +-
 .../directive_lifecycle_integration_spec.ts   |   6 +-
 modules/@angular/core/test/dom/shim_spec.ts   |   6 +-
 .../core/test/facade/observable_spec.ts       |  12 +-
 modules/@angular/core/test/fake_async_spec.ts |   8 +-
 .../core/test/forward_ref_integration_spec.ts |   2 +-
 .../change_detection_integration_spec.ts      |  36 +--
 .../linker/dynamic_component_loader_spec.ts   |  16 +-
 .../core/test/linker/integration_spec.ts      | 212 +++++++++---------
 .../linker/projection_integration_spec.ts     |  54 ++---
 .../test/linker/query_integration_spec.ts     |  82 +++----
 .../core/test/linker/query_list_spec.ts       |  10 +-
 .../reflector_component_resolver_spec.ts      |   8 +-
 .../linker/regression_integration_spec.ts     |  18 +-
 .../test/linker/security_integration_spec.ts  |  18 +-
 .../linker/view_injector_integration_spec.ts  |  38 ++--
 .../core/test/metadata/decorators_spec.ts     |   2 +-
 .../@angular/core/test/metadata/di_spec.ts    |   8 +-
 .../core/test/reflection/reflector_common.ts  |  12 +-
 .../core/test/reflection/reflector_spec.ts    |  34 +--
 .../core/test/testability/testability_spec.ts |  22 +-
 .../core/test/testing_internal_spec.ts        |  10 +-
 .../core/test/util/decorators_spec.ts         |   6 +-
 .../@angular/core/test/zone/ng_zone_spec.ts   |  54 ++---
 .../animation/mock_animation_driver.ts        |   4 +-
 .../animation/mock_animation_player.ts        |   6 +-
 modules/@angular/core/testing/async.ts        |   2 +-
 modules/@angular/core/testing/fake_async.ts   |   4 +-
 modules/@angular/core/testing/lang_utils.ts   |   2 +-
 modules/@angular/core/testing/logger.ts       |   4 +-
 modules/@angular/core/testing/regexp.ts       |   2 +-
 modules/@angular/core/testing/testing.ts      |   2 +-
 .../@angular/core/testing/testing_internal.ts |  48 ++--
 modules/@angular/facade/src/async.ts          |  14 +-
 modules/@angular/facade/src/browser.ts        |   2 +-
 modules/@angular/facade/src/collection.ts     |  12 +-
 modules/@angular/facade/src/exceptions.ts     |   4 +-
 modules/@angular/facade/src/intl.ts           |  16 +-
 modules/@angular/facade/src/lang.ts           |  32 +--
 modules/@angular/facade/src/math.ts           |   2 +-
 modules/@angular/facade/src/promise.ts        |   2 +-
 modules/@angular/facade/test/async_spec.ts    |  22 +-
 .../@angular/facade/test/collection_spec.ts   |   4 +-
 modules/@angular/facade/test/lang_spec.ts     |   8 +-
 .../@angular/http/src/backends/xhr_backend.ts |   2 +-
 modules/@angular/http/src/headers.ts          |   6 +-
 modules/@angular/http/src/static_request.ts   |   6 +-
 .../http/test/backends/xhr_backend_spec.ts    |   6 +-
 modules/@angular/http/test/headers_spec.ts    |   6 +-
 .../src/browser/browser_adapter.ts            | 144 ++++++------
 .../src/browser/testability.ts                |   6 +-
 .../src/dom/debug/ng_probe.ts                 |   6 +-
 .../platform-browser/src/dom/dom_adapter.ts   | 182 +++++++--------
 .../platform-browser/src/dom/dom_renderer.ts  |  18 +-
 .../src/dom/events/dom_events.ts              |   4 +-
 .../src/dom/events/hammer_gestures.ts         |   4 +-
 .../src/dom/events/key_events.ts              |   2 +-
 .../src/dom/shared_styles_host.ts             |   2 +-
 .../@angular/platform-browser/src/dom/util.ts |   4 +-
 .../src/dom/web_animations_driver.ts          |  14 +-
 .../src/dom/web_animations_player.ts          |   2 +-
 .../src/security/dom_sanitization_service.ts  |   2 +-
 .../src/security/html_sanitizer.ts            |   8 +-
 .../shared/client_message_broker.ts           |  10 +-
 .../shared/service_message_broker.ts          |   2 +-
 .../src/web_workers/ui/event_dispatcher.ts    |   2 +-
 .../src/web_workers/ui/event_serializer.ts    |   2 +-
 .../src/web_workers/ui/renderer.ts            |   4 +-
 .../src/web_workers/worker/renderer.ts        |   2 +-
 .../src/web_workers/worker/worker_adapter.ts  | 170 +++++++-------
 .../platform-browser/src/worker_render.ts     |   2 +-
 .../test/browser/bootstrap_spec.ts            |  36 +--
 .../test/browser/rectangle_mock.ts            |   2 +-
 .../test/browser/tools/spies.ts               |   4 +-
 .../test/dom/events/event_manager_spec.ts     |  22 +-
 .../test/dom/shared_styles_host_spec.ts       |   2 +-
 .../test/dom/web_animations_player_spec.ts    |   2 +-
 .../test/testing_public_browser_spec.ts       |  16 +-
 .../test/testing_public_spec.ts               |  46 ++--
 .../web_workers/shared/message_bus_spec.ts    |  10 +-
 .../shared/service_message_broker_spec.ts     |   6 +-
 .../shared/web_worker_test_util.ts            |   2 +-
 .../worker/platform_location_spec.ts          |   2 +-
 .../worker/renderer_integration_spec.ts       |  18 +-
 .../test/xhr/xhr_cache_setter.ts              |   2 +-
 .../test/xhr/xhr_cache_spec.ts                |   4 +-
 .../test/xhr/xhr_impl_spec.ts                 |   4 +-
 .../testing/benchmark_util.ts                 |   8 +-
 .../platform-browser/testing/browser_util.ts  |  10 +-
 .../testing/dom_test_component_renderer.ts    |   2 +-
 .../platform-browser/testing/e2e_util.ts      |   6 +-
 .../platform-browser/testing/matchers.ts      |  44 ++--
 .../platform-browser/testing/perf_util.ts     |  24 +-
 .../platform-server/src/parse5_adapter.ts     | 196 ++++++++--------
 .../src/directives/router_outlet.ts           |   2 +-
 .../router-deprecated/src/instruction.ts      |   4 +-
 .../lifecycle/route_lifecycle_reflector.ts    |   4 +-
 .../route_config/route_config_normalizer.ts   |   2 +-
 .../router-deprecated/src/route_registry.ts   |  12 +-
 .../@angular/router-deprecated/src/router.ts  |   8 +-
 .../src/rules/route_paths/param_route_path.ts |  18 +-
 .../router-deprecated/src/rules/rule_set.ts   |   6 +-
 .../router-deprecated/src/rules/rules.ts      |   4 +-
 .../router-deprecated/src/url_parser.ts       |   6 +-
 .../@angular/router-deprecated/src/utils.ts   |   2 +-
 .../test/directives/router_link_spec.ts       |  16 +-
 .../test/integration/bootstrap_spec.ts        |  32 +--
 .../integration/impl/async_route_spec_impl.ts | 156 ++++++-------
 .../integration/impl/aux_route_spec_impl.ts   |  32 +--
 .../integration/impl/sync_route_spec_impl.ts  | 108 ++++-----
 .../test/integration/lifecycle_hook_spec.ts   |  28 +--
 .../test/integration/navigation_spec.ts       |  34 +--
 .../test/integration/redirect_route_spec.ts   |  18 +-
 .../test/integration/router_link_spec.ts      |  36 +--
 .../test/integration/util.ts                  |   8 +-
 .../location/hash_location_strategy_spec.ts   |  10 +-
 .../test/location/location_spec.ts            |   8 +-
 .../location/path_location_strategy_spec.ts   |  10 +-
 .../test/route_config/route_config_spec.ts    |  36 +--
 .../test/route_registry_spec.ts               |  28 +--
 .../router-deprecated/test/router_spec.ts     |  34 +--
 .../route_paths/regex_route_param_spec.ts     |   4 +-
 .../test/rules/rule_set_spec.ts               |  26 +--
 modules/@angular/router-deprecated/testing.ts |   2 +-
 modules/@angular/router/src/link.ts           |   4 +-
 modules/@angular/router/src/recognize.ts      |  10 +-
 modules/@angular/router/src/router.ts         |   8 +-
 .../router/src/router_url_serializer.ts       |   4 +-
 modules/@angular/router/src/segments.ts       |   2 +-
 .../@angular/router/test/integration_spec.ts  |  40 ++--
 .../@angular/router/test/recognize_spec.ts    |  24 +-
 .../@angular/router/test/router_link_spec.ts  |   6 +-
 .../testing/router_testing_providers.ts       |   2 +-
 .../upgrade/src/downgrade_ng2_adapter.ts      |  30 +--
 modules/@angular/upgrade/src/metadata.ts      |   2 +-
 .../@angular/upgrade/src/upgrade_adapter.ts   |   8 +-
 .../upgrade/src/upgrade_ng1_adapter.ts        |  26 +--
 modules/@angular/upgrade/test/upgrade_spec.ts |  96 ++++----
 modules/empty.ts                              |   2 +-
 .../e2e_test/alt_routing/routing_spec.ts      |   2 +-
 .../hash_routing/hash_location_spec.ts        |   2 +-
 .../e2e_test/hello_world/hello_world_spec.ts  |   4 +-
 modules/playground/e2e_test/http/http_spec.ts |   2 +-
 .../playground/e2e_test/jsonp/jsonp_spec.ts   |   2 +-
 .../e2e_test/relative_assets/assets_spec.ts   |   4 +-
 .../e2e_test/routing/routing_spec.ts          |   2 +-
 .../e2e_test/sourcemap/sourcemap_spec.ts      |   4 +-
 .../web_workers/router/router_spec.ts         |   2 +-
 .../src/alt_routing/app/inbox-app.ts          |   6 +-
 .../playground/src/animate/app/animate-app.ts |   4 +-
 modules/playground/src/async/index.ts         |   8 +-
 modules/playground/src/bootstrap.ts           |   6 +-
 modules/playground/src/gestures/index.ts      |   6 +-
 modules/playground/src/key_events/index.ts    |   4 +-
 .../src/model_driven_forms/index.ts           |   6 +-
 .../playground/src/routing/app/inbox-app.ts   |   6 +-
 .../src/template_driven_forms/index.ts        |   6 +-
 modules/playground/src/todo/index.ts          |   6 +-
 modules/playground/src/upgrade/index.ts       |   2 +-
 .../src/web_workers/images/index_common.ts    |   4 +-
 .../src/web_workers/images/services/bitmap.ts |   4 +-
 .../src/web_workers/input/index_common.ts     |   4 +-
 .../web_workers/kitchen_sink/index_common.ts  |   2 +-
 .../src/web_workers/todo/index_common.ts      |   4 +-
 modules/tsconfig.json                         |   1 +
 305 files changed, 2338 insertions(+), 2337 deletions(-)

diff --git a/modules/@angular/common/src/directives/ng_for.ts b/modules/@angular/common/src/directives/ng_for.ts
index 860f767a0a..6afd39330a 100644
--- a/modules/@angular/common/src/directives/ng_for.ts
+++ b/modules/@angular/common/src/directives/ng_for.ts
@@ -144,7 +144,7 @@ export class NgFor implements DoCheck {
       viewRef.context.count = ilen;
     }
 
-    changes.forEachIdentityChange((record) => {
+    changes.forEachIdentityChange((record: any /** TODO #9100 */) => {
       var viewRef = <EmbeddedViewRef<NgForRow>>this._viewContainer.get(record.currentIndex);
       viewRef.context.$implicit = record.item;
     });
diff --git a/modules/@angular/common/test/directives/ng_class_spec.ts b/modules/@angular/common/test/directives/ng_class_spec.ts
index 467dbd8410..cf0ab73739 100644
--- a/modules/@angular/common/test/directives/ng_class_spec.ts
+++ b/modules/@angular/common/test/directives/ng_class_spec.ts
@@ -25,7 +25,7 @@ export function main() {
   describe('binding to CSS class list', () => {
 
     it('should clean up when the directive is destroyed',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div *ngFor="let item of items" [ngClass]="item"></div>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -44,7 +44,7 @@ export function main() {
     describe('expressions evaluating to objects', () => {
 
       it('should add classes specified in an object literal',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="{foo: true, bar: false}"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -57,7 +57,7 @@ export function main() {
 
 
       it('should add classes specified in an object literal without change in class names',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="{'foo-bar': true, 'fooBar': true}"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -69,7 +69,7 @@ export function main() {
          }));
 
       it('should add and remove classes based on changes in object literal values',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="{foo: condition, bar: !condition}"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -85,7 +85,7 @@ export function main() {
          }));
 
       it('should add and remove classes based on changes to the expression object',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -107,7 +107,7 @@ export function main() {
          }));
 
       it('should add and remove classes based on reference changes to the expression object',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -126,7 +126,7 @@ export function main() {
          }));
 
       it('should remove active classes when expression evaluates to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -146,7 +146,7 @@ export function main() {
 
 
       it('should allow multiple classes per expression',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -171,7 +171,7 @@ export function main() {
          }));
 
       it('should split by one or more spaces between classes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -190,7 +190,7 @@ export function main() {
     describe('expressions evaluating to lists', () => {
 
       it('should add classes specified in a list literal',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="['foo', 'bar', 'foo-bar', 'fooBar']"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -202,7 +202,7 @@ export function main() {
          }));
 
       it('should add and remove classes based on changes to the expression',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -225,7 +225,7 @@ export function main() {
          }));
 
       it('should add and remove classes when a reference changes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -241,7 +241,7 @@ export function main() {
          }));
 
       it('should take initial classes into account when a reference changes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div class="foo" [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -257,7 +257,7 @@ export function main() {
          }));
 
       it('should ignore empty or blank class names',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div class="foo" [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -272,7 +272,7 @@ export function main() {
          }));
 
       it('should trim blanks from class names',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div class="foo" [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -288,7 +288,7 @@ export function main() {
 
 
       it('should allow multiple classes per item in arrays',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="arrExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -310,7 +310,7 @@ export function main() {
     describe('expressions evaluating to sets', () => {
 
       it('should add and remove classes if the set instance changed',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="setExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -333,7 +333,7 @@ export function main() {
     describe('expressions evaluating to string', () => {
 
       it('should add classes specified in a string literal',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="'foo bar foo-bar fooBar'"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -345,7 +345,7 @@ export function main() {
          }));
 
       it('should add and remove classes based on changes to the expression',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="strExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -365,7 +365,7 @@ export function main() {
          }));
 
       it('should remove active classes when switching from string to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="strExpr"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -381,7 +381,7 @@ export function main() {
          }));
 
       it('should take initial classes into account when switching from string to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div class="foo" [ngClass]="strExpr"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -397,7 +397,7 @@ export function main() {
          }));
 
       it('should ignore empty and blank strings',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div class="foo" [ngClass]="strExpr"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -415,7 +415,7 @@ export function main() {
     describe('cooperation with other class-changing constructs', () => {
 
       it('should co-operate with the class attribute',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div [ngClass]="objExpr" class="init foo"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
@@ -435,7 +435,7 @@ export function main() {
          }));
 
       it('should co-operate with the interpolated class attribute',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="objExpr" class="{{'init foo'}}"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -455,7 +455,7 @@ export function main() {
          }));
 
       it('should co-operate with the class attribute and binding to it',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = `<div [ngClass]="objExpr" class="init" [class]="'foo'"></div>`;
 
            tcb.overrideTemplate(TestComponent, template)
@@ -475,7 +475,7 @@ export function main() {
          }));
 
       it('should co-operate with the class attribute and class.name binding',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<div class="init foo" [ngClass]="objExpr" [class.baz]="condition"></div>';
 
@@ -498,7 +498,7 @@ export function main() {
          }));
 
       it('should co-operate with initial class and class attribute binding when binding changes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div class="init" [ngClass]="objExpr" [class]="strExpr"></div>';
 
            tcb.overrideTemplate(TestComponent, template)
diff --git a/modules/@angular/common/test/directives/ng_for_spec.ts b/modules/@angular/common/test/directives/ng_for_spec.ts
index fb37c4c522..4b0f73e9c7 100644
--- a/modules/@angular/common/test/directives/ng_for_spec.ts
+++ b/modules/@angular/common/test/directives/ng_for_spec.ts
@@ -25,7 +25,7 @@ export function main() {
         '<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) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -36,7 +36,7 @@ export function main() {
        }));
 
     it('should reflect added elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -51,7 +51,7 @@ export function main() {
        }));
 
     it('should reflect removed elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -66,7 +66,7 @@ export function main() {
        }));
 
     it('should reflect moved elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -82,7 +82,7 @@ export function main() {
        }));
 
     it('should reflect a mix of all changes (additions/removals/moves)',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -98,7 +98,7 @@ export function main() {
        }));
 
     it('should iterate over an array of objects',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<ul><li template="ngFor let item of items">{{item["name"]}};</li></ul>';
 
          tcb.overrideTemplate(TestComponent, template)
@@ -128,7 +128,7 @@ export function main() {
        }));
 
     it('should gracefully handle nulls',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<ul><li template="ngFor let item of null">{{item}};</li></ul>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -140,7 +140,7 @@ export function main() {
        }));
 
     it('should gracefully handle ref changing to null and back',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -160,7 +160,7 @@ export function main() {
 
     if (!IS_DART) {
       it('should throw on non-iterable ref and suggest using an array',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideTemplate(TestComponent, TEMPLATE)
                .createAsync(TestComponent)
                .then((fixture) => {
@@ -177,7 +177,7 @@ export function main() {
     }
 
     it('should throw on ref changing to string',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -191,7 +191,7 @@ export function main() {
        }));
 
     it('should works with duplicates',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, TEMPLATE)
              .createAsync(TestComponent)
              .then((fixture) => {
@@ -204,7 +204,7 @@ export function main() {
        }));
 
     it('should repeat over nested arrays',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div>' +
                         '<div template="ngFor let item of items">' +
                         '<div template="ngFor let subitem of item">' +
@@ -231,7 +231,7 @@ export function main() {
        }));
 
     it('should repeat over nested arrays with no intermediate element',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div><template ngFor let-item [ngForOf]="items">' +
                         '<div template="ngFor let subitem of item">' +
                         '{{subitem}}-{{item.length}};' +
@@ -252,7 +252,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) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              `<div><template ngFor let-item [ngForOf]="items" let-i="index"><div>{{i}}|</div>` +
              `<div *ngIf="i % 2 == 0">even|</div></template></div>`;
@@ -279,7 +279,7 @@ export function main() {
        }));
 
     it('should display indices correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div><copy-me template="ngFor: let item of items; let i=index">{{i.toString()}}</copy-me></div>';
 
@@ -298,7 +298,7 @@ export function main() {
        }));
 
     it('should display first item correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div><copy-me template="ngFor: let item of items; let isFirst=first">{{isFirst.toString()}}</copy-me></div>';
 
@@ -317,7 +317,7 @@ export function main() {
        }));
 
     it('should display last item correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div><copy-me template="ngFor: let item of items; let isLast=last">{{isLast.toString()}}</copy-me></div>';
 
@@ -336,7 +336,7 @@ export function main() {
        }));
 
     it('should display even items correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div><copy-me template="ngFor: let item of items; let isEven=even">{{isEven.toString()}}</copy-me></div>';
 
@@ -355,7 +355,7 @@ export function main() {
        }));
 
     it('should display odd items correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div><copy-me template="ngFor: let item of items; let isOdd=odd">{{isOdd.toString()}}</copy-me></div>';
 
@@ -374,7 +374,7 @@ export function main() {
        }));
 
     it('should allow to use a custom template',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(
                 TestComponent,
                 '<ul><template ngFor [ngForOf]="items" [ngForTemplate]="contentTpl"></template></ul>')
@@ -393,7 +393,7 @@ export function main() {
        }));
 
     it('should use a default template if a custom one is null',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          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>')
@@ -409,7 +409,7 @@ export function main() {
        }));
 
     it('should use a custom template when both default and a custom one are present',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(TestComponent, `<ul><template ngFor let-item [ngForOf]="items"
          [ngForTemplate]="contentTpl" let-i="index">{{i}}=> {{item}};</template></ul>`)
              .overrideTemplate(
@@ -428,7 +428,7 @@ export function main() {
 
     describe('track by', function() {
       it('should not replace tracked items',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById" let-i="index">
                <p>{{items[i]}}</p>
@@ -450,7 +450,7 @@ export function main() {
                });
          }));
       it('should update implicit local variable on view',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
@@ -466,7 +466,7 @@ export function main() {
                });
          }));
       it('should move items around and keep them updated ',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
@@ -485,7 +485,7 @@ export function main() {
          }));
 
       it('should handle added and removed items properly when tracking by index',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByIndex">{{item}}</template></div>`;
            tcb.overrideTemplate(TestComponent, template)
diff --git a/modules/@angular/common/test/directives/ng_if_spec.ts b/modules/@angular/common/test/directives/ng_if_spec.ts
index 4e780cc917..e3dc88bb41 100644
--- a/modules/@angular/common/test/directives/ng_if_spec.ts
+++ b/modules/@angular/common/test/directives/ng_if_spec.ts
@@ -21,7 +21,7 @@ import {IS_DART} from '../../src/facade/lang';
 export function main() {
   describe('ngIf directive', () => {
     it('should work in a template attribute',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, html)
@@ -37,7 +37,7 @@ export function main() {
        }));
 
     it('should work in a template element',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var html =
              '<div><template [ngIf]="booleanCondition"><copy-me>hello2</copy-me></template></div>';
 
@@ -54,7 +54,7 @@ export function main() {
        }));
 
     it('should toggle node when condition changes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var html = '<div><copy-me template="ngIf booleanCondition">hello</copy-me></div>';
 
          tcb.overrideTemplate(TestComponent, html)
@@ -86,7 +86,7 @@ export function main() {
        }));
 
     it('should handle nested if correctly',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var html =
              '<div><template [ngIf]="booleanCondition"><copy-me *ngIf="nestedBooleanCondition">hello</copy-me></template></div>';
 
@@ -133,7 +133,7 @@ export function main() {
        }));
 
     it('should update several nodes with if',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var html =
              '<div>' +
              '<copy-me template="ngIf numberCondition + 1 >= 2">helloNumber</copy-me>' +
@@ -172,7 +172,7 @@ export function main() {
 
     if (!IS_DART) {
       it('should not add the element twice if the condition goes from true to true (JS)',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
 
            tcb.overrideTemplate(TestComponent, html)
@@ -198,7 +198,7 @@ export function main() {
          }));
 
       it('should not recreate the element if the condition goes from true to true (JS)',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
 
            tcb.overrideTemplate(TestComponent, html)
@@ -222,7 +222,7 @@ export function main() {
 
     if (IS_DART) {
       it('should not create the element if the condition is not a boolean (DART)',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var html = '<div><copy-me template="ngIf numberCondition">hello</copy-me></div>';
 
            tcb.overrideTemplate(TestComponent, html)
@@ -254,6 +254,6 @@ class TestComponent {
     this.nestedBooleanCondition = true;
     this.numberCondition = 1;
     this.stringCondition = "foo";
-    this.functionCondition = function(s, n) { return s == "foo" && n == 1; };
+    this.functionCondition = function(s: any /** TODO #9100 */, n: any /** TODO #9100 */) { return s == "foo" && n == 1; };
   }
 }
diff --git a/modules/@angular/common/test/directives/ng_plural_spec.ts b/modules/@angular/common/test/directives/ng_plural_spec.ts
index 952efa6172..38cfe50d41 100644
--- a/modules/@angular/common/test/directives/ng_plural_spec.ts
+++ b/modules/@angular/common/test/directives/ng_plural_spec.ts
@@ -20,7 +20,7 @@ export function main() {
     beforeEachProviders(() => [{provide: NgLocalization, useClass: TestLocalizationMap}]);
 
     it('should display the template according to the exact value',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div>' +
                         '<ul [ngPlural]="switchValue">' +
                         '<template ngPluralCase="=0"><li>you have no messages.</li></template>' +
@@ -43,7 +43,7 @@ export function main() {
        }));
 
     it('should display the template according to the category',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div>' +
              '<ul [ngPlural]="switchValue">' +
@@ -67,7 +67,7 @@ export function main() {
        }));
 
     it('should default to other when no matches are found',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div>' +
              '<ul [ngPlural]="switchValue">' +
@@ -87,7 +87,7 @@ export function main() {
        }));
 
     it('should prioritize value matches over category matches',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              '<div>' +
              '<ul [ngPlural]="switchValue">' +
diff --git a/modules/@angular/common/test/directives/ng_style_spec.ts b/modules/@angular/common/test/directives/ng_style_spec.ts
index 7360cc9b4c..1b19896843 100644
--- a/modules/@angular/common/test/directives/ng_style_spec.ts
+++ b/modules/@angular/common/test/directives/ng_style_spec.ts
@@ -24,7 +24,7 @@ export function main() {
   describe('binding to CSS styles', () => {
 
     it('should add styles specified in an object literal',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<div [ngStyle]="{'max-width': '40px'}"></div>`;
 
          tcb.overrideTemplate(TestComponent, template)
@@ -40,7 +40,7 @@ export function main() {
        }));
 
     it('should add and change styles specified in an object expression',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<div [ngStyle]="expr"></div>`;
 
          tcb.overrideTemplate(TestComponent, template)
@@ -55,7 +55,7 @@ export function main() {
                    .toEqual('40px');
 
                expr = fixture.debugElement.componentInstance.expr;
-               expr['max-width'] = '30%';
+               (expr as any /** TODO #9100 */)['max-width'] = '30%';
                fixture.detectChanges();
                expect(
                    getDOM().getStyle(fixture.debugElement.children[0].nativeElement, 'max-width'))
@@ -66,7 +66,7 @@ export function main() {
        }));
 
     it('should remove styles when deleting a key in an object expression',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<div [ngStyle]="expr"></div>`;
 
          tcb.overrideTemplate(TestComponent, template)
@@ -89,7 +89,7 @@ export function main() {
        }));
 
     it('should co-operate with the style attribute',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<div style="font-size: 12px" [ngStyle]="expr"></div>`;
 
          tcb.overrideTemplate(TestComponent, template)
@@ -118,7 +118,7 @@ export function main() {
        }));
 
     it('should co-operate with the style.[styleName]="expr" special-case in the compiler',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<div [style.font-size.px]="12" [ngStyle]="expr"></div>`;
 
          tcb.overrideTemplate(TestComponent, template)
@@ -151,5 +151,5 @@ export function main() {
 
 @Component({selector: 'test-cmp', directives: [NgStyle], template: ''})
 class TestComponent {
-  expr;
+  expr: any /** TODO #9100 */;
 }
diff --git a/modules/@angular/common/test/directives/ng_switch_spec.ts b/modules/@angular/common/test/directives/ng_switch_spec.ts
index a290bf5415..66a45148bf 100644
--- a/modules/@angular/common/test/directives/ng_switch_spec.ts
+++ b/modules/@angular/common/test/directives/ng_switch_spec.ts
@@ -18,7 +18,7 @@ export function main() {
   describe('switch', () => {
     describe('switch value changes', () => {
       it('should switch amongst when values',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div>' +
                           '<ul [ngSwitch]="switchValue">' +
                           '<template ngSwitchWhen="a"><li>when a</li></template>' +
@@ -44,7 +44,7 @@ export function main() {
          }));
 
       it('should switch amongst when values with fallback to default',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div>' +
                           '<ul [ngSwitch]="switchValue">' +
                           '<li template="ngSwitchWhen \'a\'">when a</li>' +
@@ -70,7 +70,7 @@ export function main() {
          }));
 
       it('should support multiple whens with the same value',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div>' +
                           '<ul [ngSwitch]="switchValue">' +
                           '<template ngSwitchWhen="a"><li>when a1;</li></template>' +
@@ -103,7 +103,7 @@ export function main() {
 
     describe('when values changes', () => {
       it('should switch amongst when values',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div>' +
                           '<ul [ngSwitch]="switchValue">' +
                           '<template [ngSwitchWhen]="when1"><li>when 1;</li></template>' +
diff --git a/modules/@angular/common/test/directives/ng_template_outlet_spec.ts b/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
index d57272d91e..1db5e188e0 100644
--- a/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
+++ b/modules/@angular/common/test/directives/ng_template_outlet_spec.ts
@@ -16,7 +16,7 @@ import {NgTemplateOutlet} from '@angular/common';
 export function main() {
   describe('insert', () => {
     it('should do nothing if templateRef is null',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<template [ngTemplateOutlet]="null"></template>`;
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -30,7 +30,7 @@ export function main() {
        }));
 
     it('should insert content specified by TemplateRef',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          tcb.overrideTemplate(TestComponent, template)
@@ -51,7 +51,7 @@ export function main() {
        }));
 
     it('should clear content if TemplateRef becomes null',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template =
              `<tpl-refs #refs="tplRefs"><template>foo</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          tcb.overrideTemplate(TestComponent, template)
@@ -74,7 +74,7 @@ export function main() {
        }));
 
     it('should swap content if TemplateRef changes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = `<tpl-refs #refs="tplRefs"><template>foo</template><template>bar</template></tpl-refs><template [ngTemplateOutlet]="currentTplRef"></template>`;
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
diff --git a/modules/@angular/common/test/directives/non_bindable_spec.ts b/modules/@angular/common/test/directives/non_bindable_spec.ts
index 59ce4be2d7..a69c08809f 100644
--- a/modules/@angular/common/test/directives/non_bindable_spec.ts
+++ b/modules/@angular/common/test/directives/non_bindable_spec.ts
@@ -17,7 +17,7 @@ import {AsyncTestCompleter} from '@angular/core/testing/testing_internal';
 export function main() {
   describe('non-bindable', () => {
     it('should not interpolate children',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div>{{text}}<span ngNonBindable>{{text}}</span></div>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -29,7 +29,7 @@ export function main() {
        }));
 
     it('should ignore directives on child nodes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div ngNonBindable><span id=child test-dec>{{text}}</span></div>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
@@ -45,7 +45,7 @@ export function main() {
        }));
 
     it('should trigger directives on the same node',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var template = '<div><span id=child ngNonBindable test-dec>{{text}}</span></div>';
          tcb.overrideTemplate(TestComponent, template)
              .createAsync(TestComponent)
diff --git a/modules/@angular/common/test/forms-deprecated/directives_spec.ts b/modules/@angular/common/test/forms-deprecated/directives_spec.ts
index d3d5fb0a35..26a8939fcf 100644
--- a/modules/@angular/common/test/forms-deprecated/directives_spec.ts
+++ b/modules/@angular/common/test/forms-deprecated/directives_spec.ts
@@ -44,10 +44,10 @@ import {PromiseWrapper} from '../../src/facade/promise';
 import {SimpleChange} from '@angular/core/src/change_detection';
 
 class DummyControlValueAccessor implements ControlValueAccessor {
-  writtenValue;
+  writtenValue: any /** TODO #9100 */;
 
-  registerOnChange(fn) {}
-  registerOnTouched(fn) {}
+  registerOnChange(fn: any /** TODO #9100 */) {}
+  registerOnTouched(fn: any /** TODO #9100 */) {}
 
   writeValue(obj: any): void { this.writtenValue = obj; }
 }
@@ -56,8 +56,8 @@ class CustomValidatorDirective implements Validator {
   validate(c: Control): {[key: string]: any} { return {"custom": true}; }
 }
 
-function asyncValidator(expected, timeout = 0) {
-  return (c) => {
+function asyncValidator(expected: any /** TODO #9100 */, timeout = 0) {
+  return (c: any /** TODO #9100 */) => {
     var completer = PromiseWrapper.completer();
     var res = c.value != expected ? {"async": true} : null;
     if (timeout == 0) {
@@ -120,14 +120,14 @@ export function main() {
 
       describe("composeValidators", () => {
         it("should compose functions", () => {
-          var dummy1 = (_) => ({"dummy1": true});
-          var dummy2 = (_) => ({"dummy2": true});
+          var dummy1 = (_: any /** TODO #9100 */) => ({"dummy1": true});
+          var dummy2 = (_: any /** TODO #9100 */) => ({"dummy2": true});
           var v = composeValidators([dummy1, dummy2]);
           expect(v(new Control(""))).toEqual({"dummy1": true, "dummy2": true});
         });
 
         it("should compose validator directives", () => {
-          var dummy1 = (_) => ({"dummy1": true});
+          var dummy1 = (_: any /** TODO #9100 */) => ({"dummy1": true});
           var v = composeValidators([dummy1, new CustomValidatorDirective()]);
           expect(v(new Control(""))).toEqual({"dummy1": true, "custom": true});
         });
@@ -135,9 +135,9 @@ export function main() {
     });
 
     describe("NgFormModel", () => {
-      var form;
+      var form: any /** TODO #9100 */;
       var formModel: ControlGroup;
-      var loginControlDir;
+      var loginControlDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         form = new NgFormModel([], []);
@@ -215,7 +215,7 @@ export function main() {
       });
 
       describe("addControlGroup", () => {
-        var matchingPasswordsValidator = (g) => {
+        var matchingPasswordsValidator = (g: any /** TODO #9100 */) => {
           if (g.controls["password"].value != g.controls["passwordConfirm"].value) {
             return {"differentPasswords": true};
           } else {
@@ -268,7 +268,7 @@ export function main() {
         });
 
         it("should set up a sync validator", () => {
-          var formValidator = (c) => ({"custom": true});
+          var formValidator = (c: any /** TODO #9100 */) => ({"custom": true});
           var f = new NgFormModel([formValidator], []);
           f.form = formModel;
           f.ngOnChanges({"form": new SimpleChange(null, null)});
@@ -289,10 +289,10 @@ export function main() {
     });
 
     describe("NgForm", () => {
-      var form;
+      var form: any /** TODO #9100 */;
       var formModel: ControlGroup;
-      var loginControlDir;
-      var personControlGroupDir;
+      var loginControlDir: any /** TODO #9100 */;
+      var personControlGroupDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         form = new NgForm([], []);
@@ -348,7 +348,7 @@ export function main() {
       });
 
       it("should set up sync validator", fakeAsync(() => {
-           var formValidator = (c) => ({"custom": true});
+           var formValidator = (c: any /** TODO #9100 */) => ({"custom": true});
            var f = new NgForm([formValidator], []);
 
            tick();
@@ -366,8 +366,8 @@ export function main() {
     });
 
     describe("NgControlGroup", () => {
-      var formModel;
-      var controlGroupDir;
+      var formModel: any /** TODO #9100 */;
+      var controlGroupDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         formModel = new ControlGroup({"login": new Control(null)});
@@ -391,9 +391,9 @@ export function main() {
     });
 
     describe("NgFormControl", () => {
-      var controlDir;
-      var control;
-      var checkProperties = function(control) {
+      var controlDir: any /** TODO #9100 */;
+      var control: any /** TODO #9100 */;
+      var checkProperties = function(control: any /** TODO #9100 */) {
         expect(controlDir.control).toBe(control);
         expect(controlDir.value).toBe(control.value);
         expect(controlDir.valid).toBe(control.valid);
@@ -433,7 +433,7 @@ export function main() {
     });
 
     describe("NgModel", () => {
-      var ngModel;
+      var ngModel: any /** TODO #9100 */;
 
       beforeEach(() => {
         ngModel =
@@ -468,8 +468,8 @@ export function main() {
     });
 
     describe("NgControlName", () => {
-      var formModel;
-      var controlNameDir;
+      var formModel: any /** TODO #9100 */;
+      var controlNameDir: any /** TODO #9100 */;
 
       beforeEach(() => {
         formModel = new Control("name");
diff --git a/modules/@angular/common/test/forms-deprecated/form_builder_spec.ts b/modules/@angular/common/test/forms-deprecated/form_builder_spec.ts
index 1d697597f1..2b2d932232 100644
--- a/modules/@angular/common/test/forms-deprecated/form_builder_spec.ts
+++ b/modules/@angular/common/test/forms-deprecated/form_builder_spec.ts
@@ -12,11 +12,11 @@ import {Control, FormBuilder} from '@angular/common';
 import {PromiseWrapper} from '../../src/facade/promise';
 
 export function main() {
-  function syncValidator(_) { return null; }
-  function asyncValidator(_) { return PromiseWrapper.resolve(null); }
+  function syncValidator(_: any /** TODO #9100 */): any /** TODO #9100 */ { return null; }
+  function asyncValidator(_: any /** TODO #9100 */) { return PromiseWrapper.resolve(null); }
 
   describe("Form Builder", () => {
-    var b;
+    var b: any /** TODO #9100 */;
 
     beforeEach(() => { b = new FormBuilder(); });
 
diff --git a/modules/@angular/common/test/forms-deprecated/integration_spec.ts b/modules/@angular/common/test/forms-deprecated/integration_spec.ts
index 90a18ca9fa..66200d83d2 100644
--- a/modules/@angular/common/test/forms-deprecated/integration_spec.ts
+++ b/modules/@angular/common/test/forms-deprecated/integration_spec.ts
@@ -41,7 +41,7 @@ export function main() {
   describe("integration tests", () => {
 
     it("should initialize DOM elements with the given form object",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var t = `<div [ngFormModel]="form">
                 <input type="text" ngControl="login">
                </div>`;
@@ -60,7 +60,7 @@ export function main() {
        }));
 
     it("should throw if a form isn't passed into ngFormModel",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var t = `<div [ngFormModel]="form">
                 <input type="text" ngControl="login">
                </div>`;
@@ -75,7 +75,7 @@ export function main() {
        }));
 
     it("should update the control group values on DOM change",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var form = new ControlGroup({"login": new Control("oldValue")});
 
          var t = `<div [ngFormModel]="form">
@@ -98,7 +98,7 @@ export function main() {
        }));
 
     it("should ignore the change event for <input type=text>",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var form = new ControlGroup({"login": new Control("oldValue")});
 
          var t = `<div [ngFormModel]="form">
@@ -194,7 +194,7 @@ export function main() {
       })));
 
     it("should work with single controls",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var control = new Control("loginValue");
 
          var t = `<div><input type="text" [ngFormControl]="form"></div>`;
@@ -217,7 +217,7 @@ export function main() {
        }));
 
     it("should update DOM elements when rebinding the control group",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var t = `<div [ngFormModel]="form">
                 <input type="text" ngControl="login">
                </div>`;
@@ -240,7 +240,7 @@ export function main() {
        }));
 
     it("should update DOM elements when updating the value of a control",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var login = new Control("oldValue");
          var form = new ControlGroup({"login": login});
 
@@ -265,7 +265,7 @@ export function main() {
        }));
 
     it("should mark controls as touched after interacting with the DOM control",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var login = new Control("oldValue");
          var form = new ControlGroup({"login": login});
 
@@ -292,7 +292,7 @@ export function main() {
 
     describe("different control types", () => {
       it("should support <input type=text>",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input type="text" ngControl="text">
                 </div>`;
@@ -316,7 +316,7 @@ export function main() {
          }));
 
       it("should support <input> without type",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input ngControl="text">
                 </div>`;
@@ -339,7 +339,7 @@ export function main() {
          }));
 
       it("should support <textarea>",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <textarea ngControl="text"></textarea>
                 </div>`;
@@ -363,7 +363,7 @@ export function main() {
          }));
 
       it("should support <type=checkbox>",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input type="checkbox" ngControl="checkbox">
                 </div>`;
@@ -388,7 +388,7 @@ export function main() {
          }));
 
       it("should support <type=number>",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input type="number" ngControl="num">
                 </div>`;
@@ -412,7 +412,7 @@ export function main() {
          }));
 
       it("should support <type=number> when value is cleared in the UI",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input type="number" ngControl="num" required>
                 </div>`;
@@ -442,7 +442,7 @@ export function main() {
 
 
       it("should support <type=number> when value is cleared programmatically",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form = new ControlGroup({"num": new Control(10)});
            var t = `<div [ngFormModel]="form">
                   <input type="number" ngControl="num" [(ngModel)]="data">
@@ -463,7 +463,7 @@ export function main() {
          }));
 
       it("should support <type=radio>",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<form [ngFormModel]="form">
                   <input type="radio" ngControl="foodChicken" name="food">
                   <input type="radio" ngControl="foodFish" name="food">
@@ -494,7 +494,7 @@ export function main() {
       describe("should support <select>", () => {
         it("with basic selection",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<select>
                       <option value="SF"></option>
                       <option value="NYC"></option>
@@ -516,7 +516,7 @@ export function main() {
 
         it("with basic selection and value bindings",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<select>
                       <option *ngFor="let city of list" [value]="city['id']">
                         {{ city['name'] }}
@@ -542,7 +542,7 @@ export function main() {
 
         it("with ngControl",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div [ngFormModel]="form">
                     <select ngControl="city">
                       <option value="SF"></option>
@@ -582,7 +582,7 @@ export function main() {
                       </select>
                   </div>`;
 
-             var fixture;
+             var fixture: any /** TODO #9100 */;
              tcb.overrideTemplate(MyComp8, t)
                  .createAsync(MyComp8)
                  .then((compFixture) => fixture = compFixture);
@@ -601,7 +601,7 @@ export function main() {
 
         it("with option values that are objects",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c['name']}}</option>
@@ -635,7 +635,7 @@ export function main() {
 
         it("when new options are added (selection through the model)",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c['name']}}</option>
@@ -665,7 +665,7 @@ export function main() {
 
         it("when new options are added (selection through the UI)",
             inject([TestComponentBuilder, AsyncTestCompleter],
-                (tcb: TestComponentBuilder, async) => {
+                (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c['name']}}</option>
@@ -698,7 +698,7 @@ export function main() {
 
         it("when options are removed",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c}}</option>
@@ -726,7 +726,7 @@ export function main() {
 
         it("when option values change identity while tracking by index",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list; trackBy:customTrackBy" [ngValue]="c">{{c}}</option>
@@ -758,7 +758,7 @@ export function main() {
 
         it("with duplicate option values",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c}}</option>
@@ -789,7 +789,7 @@ export function main() {
 
         it("when option values have same content, but different identities",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     var t = `<div>
                       <select [(ngModel)]="selectedCity">
                         <option *ngFor="let c of list" [ngValue]="c">{{c['name']}}</option>
@@ -819,7 +819,7 @@ export function main() {
       });
 
       it("should support custom value accessors",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <input type="text" ngControl="name" wrapped-value>
                 </div>`;
@@ -842,7 +842,7 @@ export function main() {
          }));
 
       it("should support custom value accessors on non builtin input elements that fire a change event without a 'target' property",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div [ngFormModel]="form">
                   <my-input ngControl="name"></my-input>
                 </div>`;
@@ -870,7 +870,7 @@ export function main() {
 
     describe("validations", () => {
       it("should use sync validators defined in html",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form = new ControlGroup(
                {"login": new Control(""), "min": new Control(""), "max": new Control("")});
 
@@ -924,7 +924,7 @@ export function main() {
                     <input type="text" ngControl="login" uniq-login-validator="expected">
                  </div>`;
 
-           var rootTC;
+           var rootTC: any /** TODO #9100 */;
            tcb.overrideTemplate(MyComp8, t).createAsync(MyComp8).then((root) => rootTC = root);
            tick();
 
@@ -946,7 +946,7 @@ export function main() {
          })));
 
       it("should use sync validators defined in the model",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form = new ControlGroup({"login": new Control("aa", Validators.required)});
 
            var t = `<div [ngFormModel]="form">
@@ -979,7 +979,7 @@ export function main() {
                   <input type="text" ngControl="login">
                  </div>`;
 
-           var fixture;
+           var fixture: any /** TODO #9100 */;
            tcb.overrideTemplate(MyComp8, t).createAsync(MyComp8).then((root) => fixture = root);
            tick();
 
@@ -1007,7 +1007,7 @@ export function main() {
 
     describe("nested forms", () => {
       it("should init DOM with the given form object",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form =
                new ControlGroup({"nested": new ControlGroup({"login": new Control("value")})});
 
@@ -1030,7 +1030,7 @@ export function main() {
          }));
 
       it("should update the control group values on DOM change",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form =
                new ControlGroup({"nested": new ControlGroup({"login": new Control("value")})});
 
@@ -1141,7 +1141,7 @@ export function main() {
          })));
 
       it("should not create a template-driven form when ngNoForm is used",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<form ngNoForm>
                </form>`;
 
@@ -1322,7 +1322,7 @@ export function main() {
 
     describe("setting status classes", () => {
       it("should work with single fields",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form = new Control("", Validators.required);
 
            var t = `<div><input type="text" [ngFormControl]="form"></div>`;
@@ -1353,7 +1353,7 @@ export function main() {
          }));
 
       it("should work with complex model-driven forms",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var form = new ControlGroup({"name": new Control("", Validators.required)});
 
            var t = `<form [ngFormModel]="form"><input type="text" ngControl="name"></form>`;
@@ -1384,7 +1384,7 @@ export function main() {
          }));
 
       it("should work with ngModel",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var t = `<div><input [(ngModel)]="name" required></div>`;
 
            tcb.overrideTemplate(MyComp8, t)
@@ -1486,17 +1486,17 @@ export function main() {
   host: {'(input)': 'handleOnInput($event.target.value)', '[value]': 'value'}
 })
 class WrappedValue implements ControlValueAccessor {
-  value;
+  value: any /** TODO #9100 */;
   onChange: Function;
 
   constructor(cd: NgControl) { cd.valueAccessor = this; }
 
-  writeValue(value) { this.value = `!${value}!`; }
+  writeValue(value: any /** TODO #9100 */) { this.value = `!${value}!`; }
 
-  registerOnChange(fn) { this.onChange = fn; }
-  registerOnTouched(fn) {}
+  registerOnChange(fn: any /** TODO #9100 */) { this.onChange = fn; }
+  registerOnTouched(fn: any /** TODO #9100 */) {}
 
-  handleOnInput(value) { this.onChange(value.substring(1, value.length - 1)); }
+  handleOnInput(value: any /** TODO #9100 */) { this.onChange(value.substring(1, value.length - 1)); }
 }
 
 @Component({selector: "my-input", template: ''})
@@ -1506,11 +1506,11 @@ class MyInput implements ControlValueAccessor {
 
   constructor(cd: NgControl) { cd.valueAccessor = this; }
 
-  writeValue(value) { this.value = `!${value}!`; }
+  writeValue(value: any /** TODO #9100 */) { this.value = `!${value}!`; }
 
-  registerOnChange(fn) { ObservableWrapper.subscribe(this.onInput, fn); }
+  registerOnChange(fn: any /** TODO #9100 */) { ObservableWrapper.subscribe(this.onInput, fn); }
 
-  registerOnTouched(fn) {}
+  registerOnTouched(fn: any /** TODO #9100 */) {}
 
   dispatchChangeEvent() {
     ObservableWrapper.callEmit(this.onInput, this.value.substring(1, this.value.length - 1));
@@ -1518,7 +1518,7 @@ class MyInput implements ControlValueAccessor {
 }
 
 function uniqLoginAsyncValidator(expectedValue: string) {
-  return (c) => {
+  return (c: any /** TODO #9100 */) => {
     var completer = PromiseWrapper.completer();
     var res = (c.value == expectedValue) ? null : {"uniqLogin": true};
     completer.resolve(res);
@@ -1550,9 +1550,9 @@ class LoginIsEmptyValidator {
   ]
 })
 class UniqLoginValidator implements Validator {
-  @Input('uniq-login-validator') expected;
+  @Input('uniq-login-validator') expected: any /** TODO #9100 */;
 
-  validate(c) { return uniqLoginAsyncValidator(this.expected)(c); }
+  validate(c: any /** TODO #9100 */) { return uniqLoginAsyncValidator(this.expected)(c); }
 }
 
 @Component({
@@ -1577,7 +1577,7 @@ class MyComp8 {
   customTrackBy(index: number, obj: any): number { return index; };
 }
 
-function sortedClassList(el) {
+function sortedClassList(el: any /** TODO #9100 */) {
   var l = getDOM().classList(el);
   ListWrapper.sort(l);
   return l;
diff --git a/modules/@angular/common/test/forms-deprecated/model_spec.ts b/modules/@angular/common/test/forms-deprecated/model_spec.ts
index 4d20589b89..1133e1c178 100644
--- a/modules/@angular/common/test/forms-deprecated/model_spec.ts
+++ b/modules/@angular/common/test/forms-deprecated/model_spec.ts
@@ -17,10 +17,10 @@ import {PromiseWrapper} from '../../src/facade/promise';
 import {TimerWrapper, ObservableWrapper, EventEmitter} from '../../src/facade/async';
 
 export function main() {
-  function asyncValidator(expected, timeouts = /*@ts2dart_const*/ {}) {
-    return (c) => {
+  function asyncValidator(expected: any /** TODO #9100 */, timeouts = /*@ts2dart_const*/ {}) {
+    return (c: any /** TODO #9100 */) => {
       var completer = PromiseWrapper.completer();
-      var t = isPresent(timeouts[c.value]) ? timeouts[c.value] : 0;
+      var t = isPresent((timeouts as any /** TODO #9100 */)[c.value]) ? (timeouts as any /** TODO #9100 */)[c.value] : 0;
       var res = c.value != expected ? {"async": true} : null;
 
       if (t == 0) {
@@ -33,7 +33,7 @@ export function main() {
     };
   }
 
-  function asyncValidatorReturningObservable(c) {
+  function asyncValidatorReturningObservable(c: any /** TODO #9100 */) {
     var e = new EventEmitter();
     PromiseWrapper.scheduleMicrotask(() => ObservableWrapper.callEmit(e, {"async": true}));
     return e;
@@ -140,7 +140,7 @@ export function main() {
       });
 
       describe("updateValue", () => {
-        var g, c;
+        var g: any /** TODO #9100 */, c: any /** TODO #9100 */;
         beforeEach(() => {
           c = new Control("oldValue");
           g = new ControlGroup({"one": c});
@@ -152,8 +152,8 @@ export function main() {
         });
 
         it("should invoke ngOnChanges if it is present", () => {
-          var ngOnChanges;
-          c.registerOnChange((v) => ngOnChanges = ["invoked", v]);
+          var ngOnChanges: any /** TODO #9100 */;
+          c.registerOnChange((v: any /** TODO #9100 */) => ngOnChanges = ["invoked", v]);
 
           c.updateValue("newValue");
 
@@ -161,8 +161,8 @@ export function main() {
         });
 
         it("should not invoke on change when explicitly specified", () => {
-          var onChange = null;
-          c.registerOnChange((v) => onChange = ["invoked", v]);
+          var onChange: any /** TODO #9100 */ = null;
+          c.registerOnChange((v: any /** TODO #9100 */) => onChange = ["invoked", v]);
 
           c.updateValue("newValue", {emitModelToViewChange: false});
 
@@ -197,12 +197,12 @@ export function main() {
       });
 
       describe("valueChanges & statusChanges", () => {
-        var c;
+        var c: any /** TODO #9100 */;
 
         beforeEach(() => { c = new Control("old", Validators.required); });
 
         it("should fire an event after the value has been updated",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              ObservableWrapper.subscribe(c.valueChanges, (value) => {
                expect(c.value).toEqual('new');
                expect(value).toEqual('new');
@@ -224,7 +224,7 @@ export function main() {
         it("should fire an event after the status has been updated to pending", fakeAsync(() => {
              var c = new Control("old", Validators.required, asyncValidator("expected"));
 
-             var log = [];
+             var log: any[] /** TODO #9100 */ = [];
              ObservableWrapper.subscribe(c.valueChanges, (value) => log.push(`value: '${value}'`));
              ObservableWrapper.subscribe(c.statusChanges,
                                          (status) => log.push(`status: '${status}'`));
@@ -253,8 +253,8 @@ export function main() {
         // TODO: remove the if statement after making observable delivery sync
         if (!IS_DART) {
           it("should update set errors and status before emitting an event",
-             inject([AsyncTestCompleter], (async) => {
-               c.valueChanges.subscribe(value => {
+             inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
+               c.valueChanges.subscribe((value: any /** TODO #9100 */) => {
                  expect(c.valid).toEqual(false);
                  expect(c.errors).toEqual({"required": true});
                  async.done();
@@ -263,7 +263,7 @@ export function main() {
              }));
         }
 
-        it("should return a cold observable", inject([AsyncTestCompleter], (async) => {
+        it("should return a cold observable", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              c.updateValue("will be ignored");
              ObservableWrapper.subscribe(c.valueChanges, (value) => {
                expect(value).toEqual('new');
@@ -380,7 +380,7 @@ export function main() {
 
       describe("errors", () => {
         it("should run the validator when the value changes", () => {
-          var simpleValidator = (c) =>
+          var simpleValidator = (c: any /** TODO #9100 */) =>
               c.controls["one"].value != "correct" ? {"broken": true} : null;
 
           var c = new Control(null);
@@ -399,7 +399,7 @@ export function main() {
       });
 
       describe("dirty", () => {
-        var c, g;
+        var c: any /** TODO #9100 */, g: any /** TODO #9100 */;
 
         beforeEach(() => {
           c = new Control('value');
@@ -417,7 +417,7 @@ export function main() {
 
       describe("optional components", () => {
         describe("contains", () => {
-          var group;
+          var group: any /** TODO #9100 */;
 
           beforeEach(() => {
             group = new ControlGroup(
@@ -473,7 +473,7 @@ export function main() {
       });
 
       describe("valueChanges", () => {
-        var g, c1, c2;
+        var g: any /** TODO #9100 */, c1: any /** TODO #9100 */, c2: any /** TODO #9100 */;
 
         beforeEach(() => {
           c1 = new Control("old1");
@@ -482,7 +482,7 @@ export function main() {
         });
 
         it("should fire an event after the value has been updated",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              ObservableWrapper.subscribe(g.valueChanges, (value) => {
                expect(g.value).toEqual({'one': 'new1', 'two': 'old2'});
                expect(value).toEqual({'one': 'new1', 'two': 'old2'});
@@ -492,7 +492,7 @@ export function main() {
            }));
 
         it("should fire an event after the control's observable fired an event",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              var controlCallbackIsCalled = false;
 
              ObservableWrapper.subscribe(c1.valueChanges,
@@ -507,7 +507,7 @@ export function main() {
            }));
 
         it("should fire an event when a control is excluded",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              ObservableWrapper.subscribe(g.valueChanges, (value) => {
                expect(value).toEqual({'one': 'old1'});
                async.done();
@@ -517,7 +517,7 @@ export function main() {
            }));
 
         it("should fire an event when a control is included",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              g.exclude("two");
 
              ObservableWrapper.subscribe(g.valueChanges, (value) => {
@@ -529,8 +529,8 @@ export function main() {
            }));
 
         it("should fire an event every time a control is updated",
-           inject([AsyncTestCompleter], (async) => {
-             var loggedValues = [];
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
+             var loggedValues: any[] /** TODO #9100 */ = [];
 
              ObservableWrapper.subscribe(g.valueChanges, (value) => {
                loggedValues.push(value);
@@ -547,7 +547,7 @@ export function main() {
            }));
 
         xit("should not fire an event when an excluded control is updated",
-            inject([AsyncTestCompleter], (async) => {
+            inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
                                              // hard to test without hacking zones
                                          }));
       });
@@ -609,7 +609,7 @@ export function main() {
     describe("ControlArray", () => {
       describe("adding/removing", () => {
         var a: ControlArray;
-        var c1, c2, c3;
+        var c1: any /** TODO #9100 */, c2: any /** TODO #9100 */, c3: any /** TODO #9100 */;
 
         beforeEach(() => {
           a = new ControlArray([]);
@@ -658,7 +658,7 @@ export function main() {
 
       describe("errors", () => {
         it("should run the validator when the value changes", () => {
-          var simpleValidator = (c) => c.controls[0].value != "correct" ? {"broken": true} : null;
+          var simpleValidator = (c: any /** TODO #9100 */) => c.controls[0].value != "correct" ? {"broken": true} : null;
 
           var c = new Control(null);
           var g = new ControlArray([c], simpleValidator);
@@ -725,7 +725,7 @@ export function main() {
 
       describe("valueChanges", () => {
         var a: ControlArray;
-        var c1, c2;
+        var c1: any /** TODO #9100 */, c2: any /** TODO #9100 */;
 
         beforeEach(() => {
           c1 = new Control("old1");
@@ -734,7 +734,7 @@ export function main() {
         });
 
         it("should fire an event after the value has been updated",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              ObservableWrapper.subscribe(a.valueChanges, (value) => {
                expect(a.value).toEqual(['new1', 'old2']);
                expect(value).toEqual(['new1', 'old2']);
@@ -744,7 +744,7 @@ export function main() {
            }));
 
         it("should fire an event after the control's observable fired an event",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              var controlCallbackIsCalled = false;
 
              ObservableWrapper.subscribe(c1.valueChanges,
@@ -759,7 +759,7 @@ export function main() {
            }));
 
         it("should fire an event when a control is removed",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              ObservableWrapper.subscribe(a.valueChanges, (value) => {
                expect(value).toEqual(['old1']);
                async.done();
@@ -768,7 +768,7 @@ export function main() {
              a.removeAt(1);
            }));
 
-        it("should fire an event when a control is added", inject([AsyncTestCompleter], (async) => {
+        it("should fire an event when a control is added", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              a.removeAt(1);
 
              ObservableWrapper.subscribe(a.valueChanges, (value) => {
diff --git a/modules/@angular/common/test/forms-deprecated/validators_spec.ts b/modules/@angular/common/test/forms-deprecated/validators_spec.ts
index 0aa5c89b82..33ba2c0cfd 100644
--- a/modules/@angular/common/test/forms-deprecated/validators_spec.ts
+++ b/modules/@angular/common/test/forms-deprecated/validators_spec.ts
@@ -17,7 +17,7 @@ export function main() {
   function validator(key: string, error: any) {
     return function(c: AbstractControl) {
       var r = {};
-      r[key] = error;
+      (r as any /** TODO #9100 */)[key] = error;
       return r;
     }
   }
@@ -111,8 +111,8 @@ export function main() {
     });
 
     describe("composeAsync", () => {
-      function asyncValidator(expected, response) {
-        return (c) => {
+      function asyncValidator(expected: any /** TODO #9100 */, response: any /** TODO #9100 */) {
+        return (c: any /** TODO #9100 */) => {
           var emitter = new EventEmitter();
           var res = c.value != expected ? response : null;
 
@@ -136,7 +136,7 @@ export function main() {
              asyncValidator("expected", {"two": true})
            ]);
 
-           var value = null;
+           var value: any /** TODO #9100 */ = null;
            (<Promise<any>>c(new Control("invalid"))).then(v => value = v);
 
            tick(1);
@@ -147,7 +147,7 @@ export function main() {
       it("should return null when no errors", fakeAsync(() => {
            var c = Validators.composeAsync([asyncValidator("expected", {"one": true})]);
 
-           var value = null;
+           var value: any /** TODO #9100 */ = null;
            (<Promise<any>>c(new Control("expected"))).then(v => value = v);
 
            tick(1);
@@ -158,7 +158,7 @@ export function main() {
       it("should ignore nulls", fakeAsync(() => {
            var c = Validators.composeAsync([asyncValidator("expected", {"one": true}), null]);
 
-           var value = null;
+           var value: any /** TODO #9100 */ = null;
            (<Promise<any>>c(new Control("invalid"))).then(v => value = v);
 
            tick(1);
diff --git a/modules/@angular/common/test/pipes/async_pipe_spec.ts b/modules/@angular/common/test/pipes/async_pipe_spec.ts
index 726895ee99..da42d1fc89 100644
--- a/modules/@angular/common/test/pipes/async_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/async_pipe_spec.ts
@@ -28,9 +28,9 @@ export function main() {
   describe("AsyncPipe", () => {
 
     describe('Observable', () => {
-      var emitter;
-      var pipe;
-      var ref;
+      var emitter: any /** TODO #9100 */;
+      var pipe: any /** TODO #9100 */;
+      var ref: any /** TODO #9100 */;
       var message = new Object();
 
       beforeEach(() => {
@@ -44,7 +44,7 @@ export function main() {
            () => { expect(pipe.transform(emitter)).toBe(null); });
 
         it("should return the latest available value wrapped",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(emitter);
 
              ObservableWrapper.callEmit(emitter, message);
@@ -57,7 +57,7 @@ export function main() {
 
 
         it("should return same value when nothing has changed since the last call",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(emitter);
              ObservableWrapper.callEmit(emitter, message);
 
@@ -69,7 +69,7 @@ export function main() {
            }));
 
         it("should dispose of the existing subscription when subscribing to a new observable",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(emitter);
 
              var newEmitter = new EventEmitter();
@@ -85,7 +85,7 @@ export function main() {
            }));
 
         it("should request a change detection check upon receiving a new value",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(emitter);
              ObservableWrapper.callEmit(emitter, message);
 
@@ -100,7 +100,7 @@ export function main() {
         it("should do nothing when no subscription",
            () => { expect(() => pipe.ngOnDestroy()).not.toThrow(); });
 
-        it("should dispose of the existing subscription", inject([AsyncTestCompleter], (async) => {
+        it("should dispose of the existing subscription", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(emitter);
              pipe.ngOnDestroy();
 
@@ -132,7 +132,7 @@ export function main() {
         it("should return null when subscribing to a promise",
            () => { expect(pipe.transform(completer.promise)).toBe(null); });
 
-        it("should return the latest available value", inject([AsyncTestCompleter], (async) => {
+        it("should return the latest available value", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(completer.promise);
 
              completer.resolve(message);
@@ -144,7 +144,7 @@ export function main() {
            }));
 
         it("should return unwrapped value when nothing has changed since the last call",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(completer.promise);
              completer.resolve(message);
 
@@ -156,7 +156,7 @@ export function main() {
            }));
 
         it("should dispose of the existing subscription when subscribing to a new promise",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              pipe.transform(completer.promise);
 
              var newCompleter = PromiseWrapper.completer();
@@ -172,7 +172,7 @@ export function main() {
            }));
 
         it("should request a change detection check upon receiving a new value",
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              var markForCheck = ref.spy('markForCheck');
              pipe.transform(completer.promise);
              completer.resolve(message);
@@ -187,7 +187,7 @@ export function main() {
           it("should do nothing when no source",
              () => { expect(() => pipe.ngOnDestroy()).not.toThrow(); });
 
-          it("should dispose of the existing source", inject([AsyncTestCompleter], (async) => {
+          it("should dispose of the existing source", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
                pipe.transform(completer.promise);
                expect(pipe.transform(completer.promise)).toBe(null);
                completer.resolve(message)
diff --git a/modules/@angular/common/test/pipes/date_pipe_spec.ts b/modules/@angular/common/test/pipes/date_pipe_spec.ts
index 60ab8c0afa..43cde9d650 100644
--- a/modules/@angular/common/test/pipes/date_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/date_pipe_spec.ts
@@ -16,8 +16,8 @@ import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
 
 export function main() {
   describe("DatePipe", () => {
-    var date;
-    var pipe;
+    var date: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     beforeEach(() => {
       date = DateWrapper.create(2015, 6, 15, 21, 43, 11);
diff --git a/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts b/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts
index 94b2c68315..9c63aeadb2 100644
--- a/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/i18n_plural_pipe_spec.ts
@@ -14,7 +14,7 @@ import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
 
 export function main() {
   describe("I18nPluralPipe", () => {
-    var pipe;
+    var pipe: any /** TODO #9100 */;
     var mapping = {'=0': 'No messages.', '=1': 'One message.', 'other': 'There are some messages.'};
     var interpolatedMapping =
         {'=0': 'No messages.', '=1': 'One message.', 'other': 'There are # messages, that is #.'};
@@ -46,7 +46,7 @@ export function main() {
       });
 
       it("should use 'other' if value is undefined", () => {
-        var messageLength;
+        var messageLength: any /** TODO #9100 */;
         var val = pipe.transform(messageLength, interpolatedMapping);
         expect(val).toEqual('There are  messages, that is .');
       });
diff --git a/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts b/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts
index f932e0d309..e5c60eced2 100644
--- a/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/i18n_select_pipe_spec.ts
@@ -14,7 +14,7 @@ import {PipeResolver} from '@angular/compiler/src/pipe_resolver';
 
 export function main() {
   describe("I18nSelectPipe", () => {
-    var pipe;
+    var pipe: any /** TODO #9100 */;
     var mapping = {'male': 'Invite him.', 'female': 'Invite her.', 'other': 'Invite them.'};
 
     beforeEach(() => { pipe = new I18nSelectPipe(); });
@@ -39,7 +39,7 @@ export function main() {
       });
 
       it("should use 'other' if value is undefined", () => {
-        var gender;
+        var gender: any /** TODO #9100 */;
         var val = pipe.transform(gender, mapping);
         expect(val).toEqual('Invite them.');
       });
diff --git a/modules/@angular/common/test/pipes/json_pipe_spec.ts b/modules/@angular/common/test/pipes/json_pipe_spec.ts
index afcc96c88f..77661ece3a 100644
--- a/modules/@angular/common/test/pipes/json_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/json_pipe_spec.ts
@@ -19,9 +19,9 @@ import {JsonPipe} from '@angular/common';
 export function main() {
   describe("JsonPipe", () => {
     var regNewLine = '\n';
-    var inceptionObj;
-    var inceptionObjString;
-    var pipe;
+    var inceptionObj: any /** TODO #9100 */;
+    var inceptionObjString: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     function normalize(obj: string): string { return StringWrapper.replace(obj, regNewLine, ''); }
 
@@ -53,7 +53,7 @@ export function main() {
 
     describe('integration', () => {
       it('should work with mutable objects',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.createAsync(TestComp).then((fixture) => {
              let mutable: number[] = [1];
              fixture.debugElement.componentInstance.data = mutable;
diff --git a/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts b/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts
index c75278c127..207b0342d9 100644
--- a/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts
@@ -13,9 +13,9 @@ import {LowerCasePipe} from '@angular/common';
 
 export function main() {
   describe("LowerCasePipe", () => {
-    var upper;
-    var lower;
-    var pipe;
+    var upper: any /** TODO #9100 */;
+    var lower: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     beforeEach(() => {
       lower = 'something';
diff --git a/modules/@angular/common/test/pipes/number_pipe_spec.ts b/modules/@angular/common/test/pipes/number_pipe_spec.ts
index 5828dfe302..eae8a3e19f 100644
--- a/modules/@angular/common/test/pipes/number_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/number_pipe_spec.ts
@@ -18,7 +18,7 @@ export function main() {
     // https://github.com/angular/angular/issues/3333
     if (browserDetection.supportsIntlApi) {
       describe("DecimalPipe", () => {
-        var pipe;
+        var pipe: any /** TODO #9100 */;
 
         beforeEach(() => { pipe = new DecimalPipe(); });
 
@@ -39,7 +39,7 @@ export function main() {
       });
 
       describe("PercentPipe", () => {
-        var pipe;
+        var pipe: any /** TODO #9100 */;
 
         beforeEach(() => { pipe = new PercentPipe(); });
 
@@ -55,7 +55,7 @@ export function main() {
       });
 
       describe("CurrencyPipe", () => {
-        var pipe;
+        var pipe: any /** TODO #9100 */;
 
         beforeEach(() => { pipe = new CurrencyPipe(); });
 
diff --git a/modules/@angular/common/test/pipes/replace_pipe_spec.ts b/modules/@angular/common/test/pipes/replace_pipe_spec.ts
index ab9d21a1ca..734617e824 100644
--- a/modules/@angular/common/test/pipes/replace_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/replace_pipe_spec.ts
@@ -17,8 +17,8 @@ import {RegExpWrapper, StringJoiner} from '../../src/facade/lang';
 export function main() {
   describe("ReplacePipe", () => {
     var someNumber: number;
-    var str;
-    var pipe;
+    var str: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     beforeEach(() => {
       someNumber = 42;
@@ -52,7 +52,7 @@ export function main() {
 
         var result3 = pipe.transform(str, RegExpWrapper.create("a", "i"), "_");
 
-        var f = (x => { return "Adams!"; });
+        var f = ((x: any /** TODO #9100 */) => { return "Adams!"; });
 
         var result4 = pipe.transform(str, "Adams", f);
 
diff --git a/modules/@angular/common/test/pipes/slice_pipe_spec.ts b/modules/@angular/common/test/pipes/slice_pipe_spec.ts
index a83ce3c7c5..3658f6db94 100644
--- a/modules/@angular/common/test/pipes/slice_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/slice_pipe_spec.ts
@@ -20,8 +20,8 @@ import {SlicePipe} from '@angular/common';
 export function main() {
   describe("SlicePipe", () => {
     var list: number[];
-    var str;
-    var pipe;
+    var str: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     beforeEach(() => {
       list = [1, 2, 3, 4, 5];
@@ -95,7 +95,7 @@ export function main() {
 
     describe('integration', () => {
       it('should work with mutable arrays',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.createAsync(TestComp).then((fixture) => {
              let mutable: number[] = [1, 2];
              fixture.debugElement.componentInstance.data = mutable;
diff --git a/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts b/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts
index b463d4df77..fb66ec2337 100644
--- a/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts
@@ -12,9 +12,9 @@ import {UpperCasePipe} from '@angular/common';
 
 export function main() {
   describe("UpperCasePipe", () => {
-    var upper;
-    var lower;
-    var pipe;
+    var upper: any /** TODO #9100 */;
+    var lower: any /** TODO #9100 */;
+    var pipe: any /** TODO #9100 */;
 
     beforeEach(() => {
       lower = 'something';
diff --git a/modules/@angular/compiler/src/animation/animation_compiler.ts b/modules/@angular/compiler/src/animation/animation_compiler.ts
index e1d23badaf..7c56760911 100644
--- a/modules/@angular/compiler/src/animation/animation_compiler.ts
+++ b/modules/@angular/compiler/src/animation/animation_compiler.ts
@@ -88,7 +88,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
 
   visitAnimationStyles(ast: AnimationStylesAst,
                        context: _AnimationBuilderContext): o.Expression {
-    var stylesArr = [];
+    var stylesArr: any[] /** TODO #9100 */ = [];
     if (context.isExpectingFirstStyleStep) {
       stylesArr.push(_ANIMATION_START_STATE_STYLES_VAR);
       context.isExpectingFirstStyleStep = false;
@@ -139,7 +139,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
   }
 
   /** @internal */
-  _callAnimateMethod(ast: AnimationStepAst, startingStylesExpr, keyframesExpr) {
+  _callAnimateMethod(ast: AnimationStepAst, startingStylesExpr: any /** TODO #9100 */, keyframesExpr: any /** TODO #9100 */) {
     return _ANIMATION_FACTORY_RENDERER_VAR.callMethod('animate', [
       _ANIMATION_FACTORY_ELEMENT_VAR,
       startingStylesExpr,
@@ -165,8 +165,8 @@ class _AnimationBuilder implements AnimationAstVisitor {
 
   visitAnimationStateDeclaration(ast: AnimationStateDeclarationAst, context: _AnimationBuilderContext): void {
     var flatStyles: {[key: string]: string|number} = {};
-    _getStylesArray(ast).forEach(entry => {
-      StringMapWrapper.forEach(entry, (value, key) => {
+    _getStylesArray(ast).forEach((entry: any /** TODO #9100 */) => {
+      StringMapWrapper.forEach(entry, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => {
         flatStyles[key] = value;
       });
     });
@@ -182,7 +182,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
 
     context.isExpectingFirstStyleStep = true;
 
-    var stateChangePreconditions = [];
+    var stateChangePreconditions: any[] /** TODO #9100 */ = [];
 
     ast.stateChanges.forEach(stateChange => {
       stateChangePreconditions.push(
@@ -216,7 +216,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     //this should always be defined even if the user overrides it
     context.stateMap.registerState(DEFAULT_STATE, {});
 
-    var statements = [];
+    var statements: any[] /** TODO #9100 */ = [];
     statements.push(
       _ANIMATION_FACTORY_VIEW_VAR.callMethod('cancelActiveAnimation', [
         _ANIMATION_FACTORY_ELEMENT_VAR,
@@ -313,12 +313,12 @@ class _AnimationBuilder implements AnimationAstVisitor {
     var fnStatement = ast.visit(this, context).toDeclStmt(this._fnVarName);
     var fnVariable = o.variable(this._fnVarName);
 
-    var lookupMap = [];
-    StringMapWrapper.forEach(context.stateMap.states, (value, stateName) => {
+    var lookupMap: any[] /** TODO #9100 */ = [];
+    StringMapWrapper.forEach(context.stateMap.states, (value: any /** TODO #9100 */, stateName: any /** TODO #9100 */) => {
       var variableValue = EMPTY_MAP;
       if (isPresent(value)) {
-        let styleMap = [];
-        StringMapWrapper.forEach(value, (value, key) => {
+        let styleMap: any[] /** TODO #9100 */ = [];
+        StringMapWrapper.forEach(value, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => {
           styleMap.push([key, o.literal(value)]);
         });
         variableValue = o.literalMap(styleMap);
diff --git a/modules/@angular/compiler/src/animation/animation_parser.ts b/modules/@angular/compiler/src/animation/animation_parser.ts
index 8317e91c7e..48abb22457 100644
--- a/modules/@angular/compiler/src/animation/animation_parser.ts
+++ b/modules/@angular/compiler/src/animation/animation_parser.ts
@@ -46,7 +46,7 @@ const _TERMINAL_KEYFRAME = 1;
 const _ONE_SECOND = 1000;
 
 export class AnimationParseError extends ParseError {
-  constructor(message) { super(null, message); }
+  constructor(message: any /** TODO #9100 */) { super(null, message); }
   toString(): string { return `${this.msg}`; }
 }
 
@@ -59,7 +59,7 @@ export function parseAnimationEntry(entry: CompileAnimationEntryMetadata): Parse
   var stateStyles: {[key: string]: AnimationStylesAst} = {};
   var transitions: CompileAnimationStateTransitionMetadata[] = [];
 
-  var stateDeclarationAsts = [];
+  var stateDeclarationAsts: any[] /** TODO #9100 */ = [];
   entry.definitions.forEach(def => {
     if (def instanceof CompileAnimationStateDeclarationMetadata) {
       _parseAnimationDeclarationStates(def, errors).forEach(ast => {
@@ -98,7 +98,7 @@ function _parseAnimationStateTransition(transitionStateMetadata: CompileAnimatio
                                         stateStyles: {[key: string]: AnimationStylesAst},
                                         errors: AnimationParseError[]): AnimationStateTransitionAst {
   var styles = new StylesCollection();
-  var transitionExprs = [];
+  var transitionExprs: any[] /** TODO #9100 */ = [];
   var transitionStates = transitionStateMetadata.stateChangeExpr.split(/\s*,\s*/);
   transitionStates.forEach(expr => {
     _parseAnimationTransitionExpr(expr, errors).forEach(transExpr => {
@@ -120,7 +120,7 @@ function _parseAnimationStateTransition(transitionStateMetadata: CompileAnimatio
 }
 
 function _parseAnimationTransitionExpr(eventStr: string, errors: AnimationParseError[]): AnimationStateTransitionExpression[] {
-  var expressions = [];
+  var expressions: any[] /** TODO #9100 */ = [];
   var match = eventStr.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);
   if (!isPresent(match) || match.length < 4) {
     errors.push(new AnimationParseError(`the provided ${eventStr} is not of a supported format`));
@@ -161,7 +161,7 @@ function _normalizeAnimationEntry(entry: CompileAnimationMetadata | CompileAnima
 function _normalizeStyleMetadata(entry: CompileAnimationStyleMetadata,
                                  stateStyles: {[key: string]: AnimationStylesAst},
                                  errors: AnimationParseError[]): Array<{[key: string]: string|number}> {
-  var normalizedStyles = [];
+  var normalizedStyles: any[] /** TODO #9100 */ = [];
   entry.styles.forEach(styleEntry => {
     if (isString(styleEntry)) {
       ListWrapper.addAll(normalizedStyles, _resolveStylesFromState(<string>styleEntry, stateStyles, errors));
@@ -299,7 +299,7 @@ function _parseAnimationKeyframes(keyframeSequence: CompileAnimationKeyframesSeq
 
   var limit = totalEntries - 1;
   var margin = totalOffsets == 0 ? (1 / limit) : 0;
-  var rawKeyframes = [];
+  var rawKeyframes: any[] /** TODO #9100 */ = [];
   var index = 0;
   var doSortKeyframes = false;
   var lastOffset = 0;
@@ -307,7 +307,7 @@ function _parseAnimationKeyframes(keyframeSequence: CompileAnimationKeyframesSeq
     var offset = styleMetadata.offset;
     var keyframeStyles: {[key: string]: string|number} = {};
     styleMetadata.styles.forEach(entry => {
-      StringMapWrapper.forEach(<{[key: string]: string|number}>entry, (value, prop) => {
+      StringMapWrapper.forEach(<{[key: string]: string|number}>entry, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
         if (prop != 'offset') {
           keyframeStyles[prop] = value;
         }
@@ -329,7 +329,7 @@ function _parseAnimationKeyframes(keyframeSequence: CompileAnimationKeyframesSeq
     ListWrapper.sort(rawKeyframes, (a,b) => a[0] <= b[0] ? -1 : 1);
   }
 
-  var i;
+  var i: any /** TODO #9100 */;
   var firstKeyframe = rawKeyframes[0];
   if (firstKeyframe[0] != _INITIAL_KEYFRAME) {
     ListWrapper.insert(rawKeyframes, 0, firstKeyframe = [_INITIAL_KEYFRAME, {}]);
@@ -348,7 +348,7 @@ function _parseAnimationKeyframes(keyframeSequence: CompileAnimationKeyframesSeq
     let entry = rawKeyframes[i];
     let styles = entry[1];
 
-    StringMapWrapper.forEach(styles, (value, prop) => {
+    StringMapWrapper.forEach(styles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
       if (!isPresent(firstKeyframeStyles[prop])) {
         firstKeyframeStyles[prop] = FILL_STYLE_FLAG;
       }
@@ -359,7 +359,7 @@ function _parseAnimationKeyframes(keyframeSequence: CompileAnimationKeyframesSeq
     let entry = rawKeyframes[i];
     let styles = entry[1];
 
-    StringMapWrapper.forEach(styles, (value, prop) => {
+    StringMapWrapper.forEach(styles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
       if (!isPresent(lastKeyframeStyles[prop])) {
         lastKeyframeStyles[prop] = value;
       }
@@ -374,14 +374,14 @@ function _parseTransitionAnimation(entry: CompileAnimationMetadata,
                                       collectedStyles: StylesCollection,
                                       stateStyles: {[key: string]: AnimationStylesAst},
                                       errors: AnimationParseError[]): AnimationAst {
-  var ast;
+  var ast: any /** TODO #9100 */;
   var playTime = 0;
   var startingTime = currentTime;
   if (entry instanceof CompileAnimationWithStepsMetadata) {
     var maxDuration = 0;
-    var steps = [];
+    var steps: any[] /** TODO #9100 */ = [];
     var isGroup = entry instanceof CompileAnimationGroupMetadata;
-    var previousStyles;
+    var previousStyles: any /** TODO #9100 */;
     entry.steps.forEach(entry => {
       // these will get picked up by the next step...
       var time = isGroup ? startingTime : currentTime;
@@ -389,7 +389,7 @@ function _parseTransitionAnimation(entry: CompileAnimationMetadata,
         entry.styles.forEach(stylesEntry => {
           // by this point we know that we only have stringmap values
           var map = <{[key: string]: string|number}>stylesEntry;
-          StringMapWrapper.forEach(map, (value, prop) => {
+          StringMapWrapper.forEach(map, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
             collectedStyles.insertAtTime(prop, time, value);
           });
         });
@@ -430,7 +430,7 @@ function _parseTransitionAnimation(entry: CompileAnimationMetadata,
     var timings = _parseTimeExpression(entry.timings, errors);
     var styles = entry.styles;
 
-    var keyframes;
+    var keyframes: any /** TODO #9100 */;
     if (styles instanceof CompileAnimationKeyframesSequenceMetadata) {
       keyframes = _parseAnimationKeyframes(styles, currentTime, collectedStyles, stateStyles, errors);
     } else {
@@ -445,9 +445,9 @@ function _parseTransitionAnimation(entry: CompileAnimationMetadata,
     playTime = timings.duration + timings.delay;
     currentTime += playTime;
 
-    keyframes.forEach(keyframe =>
-      keyframe.styles.styles.forEach(entry =>
-        StringMapWrapper.forEach(entry, (value, prop) =>
+    keyframes.forEach((keyframe: any /** TODO #9100 */) =>
+      keyframe.styles.styles.forEach((entry: any /** TODO #9100 */) =>
+        StringMapWrapper.forEach(entry, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) =>
           collectedStyles.insertAtTime(prop, currentTime, value))
       )
     );
@@ -526,11 +526,11 @@ function _createStartKeyframeFromEndKeyframe(endKeyframe: AnimationKeyframeAst,
   var values: {[key: string]: string | number} = {};
   var endTime = startTime + duration;
   endKeyframe.styles.styles.forEach((styleData: {[key: string]: string|number}) => {
-    StringMapWrapper.forEach(styleData, (val, prop) => {
+    StringMapWrapper.forEach(styleData, (val: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
       if (prop == 'offset') return;
 
       var resultIndex = collectedStyles.indexOfAtOrBeforeTime(prop, startTime);
-      var resultEntry, nextEntry, value;
+      var resultEntry: any /** TODO #9100 */, nextEntry: any /** TODO #9100 */, value: any /** TODO #9100 */;
       if (isPresent(resultIndex)) {
         resultEntry = collectedStyles.getByIndex(prop, resultIndex);
         value = resultEntry.value;
diff --git a/modules/@angular/compiler/src/compile_metadata.ts b/modules/@angular/compiler/src/compile_metadata.ts
index 9deb8546e1..0d342f3aeb 100644
--- a/modules/@angular/compiler/src/compile_metadata.ts
+++ b/modules/@angular/compiler/src/compile_metadata.ts
@@ -46,7 +46,7 @@ export abstract class CompileMetadataWithType extends CompileMetadataWithIdentif
 }
 
 export function metadataFromJson(data: {[key: string]: any}): any {
-  return _COMPILE_METADATA_FROM_JSON[data['class']](data);
+  return (_COMPILE_METADATA_FROM_JSON as any /** TODO #9100 */)[data['class']](data);
 }
 
 export class CompileAnimationEntryMetadata {
@@ -523,7 +523,7 @@ export class CompileTokenMap<VALUE> {
   get(token: CompileTokenMetadata): VALUE {
     var rk = token.runtimeCacheKey;
     var ak = token.assetCacheKey;
-    var result;
+    var result: any /** TODO #9100 */;
     if (isPresent(rk)) {
       result = this._valueMap.get(rk);
     }
diff --git a/modules/@angular/compiler/src/config.ts b/modules/@angular/compiler/src/config.ts
index 4d72de81cf..acd00eb053 100644
--- a/modules/@angular/compiler/src/config.ts
+++ b/modules/@angular/compiler/src/config.ts
@@ -38,9 +38,9 @@ export abstract class RenderTypes {
 
 export class DefaultRenderTypes implements RenderTypes {
   renderer = Identifiers.Renderer;
-  renderText = null;
-  renderElement = null;
-  renderComment = null;
-  renderNode = null;
-  renderEvent = null;
+  renderText: any /** TODO #9100 */ = null;
+  renderElement: any /** TODO #9100 */ = null;
+  renderComment: any /** TODO #9100 */ = null;
+  renderNode: any /** TODO #9100 */ = null;
+  renderEvent: any /** TODO #9100 */ = null;
 }
diff --git a/modules/@angular/compiler/src/css/lexer.ts b/modules/@angular/compiler/src/css/lexer.ts
index eca9cbde16..5779fc8a4e 100644
--- a/modules/@angular/compiler/src/css/lexer.ts
+++ b/modules/@angular/compiler/src/css/lexer.ts
@@ -137,7 +137,7 @@ export class CssScannerError extends BaseException {
   public rawMessage: string;
   public message: string;
 
-  constructor(public token: CssToken, message) {
+  constructor(public token: CssToken, message: any /** TODO #9100 */) {
     super('Css Parse Error: ' + message);
     this.rawMessage = message;
   }
@@ -251,7 +251,7 @@ export class CssScanner {
       next = new CssToken(0, 0, 0, CssTokenType.EOF, "end of file");
     }
 
-    var isMatchingType;
+    var isMatchingType: any /** TODO #9100 */;
     if (type == CssTokenType.IdentifierOrNumber) {
       // TODO (matsko): implement array traversal for lookup here
       isMatchingType = next.type == CssTokenType.Number || next.type == CssTokenType.Identifier;
@@ -263,7 +263,7 @@ export class CssScanner {
     // mode so that the parser can recover...
     this.setMode(mode);
 
-    var error = null;
+    var error: any /** TODO #9100 */ = null;
     if (!isMatchingType || (isPresent(value) && value != next.strValue)) {
       var errorMessage = resolveEnumToken(CssTokenType, next.type) + " does not match expected " +
                          resolveEnumToken(CssTokenType, type) + " value";
@@ -740,7 +740,7 @@ function isValidCssCharacter(code: number, mode: CssLexerMode): boolean {
   }
 }
 
-function charCode(input, index): number {
+function charCode(input: any /** TODO #9100 */, index: any /** TODO #9100 */): number {
   return index >= input.length ? $EOF : StringWrapper.charCodeAt(input, index);
 }
 
@@ -748,7 +748,7 @@ function charStr(code: number): string {
   return StringWrapper.fromCharCode(code);
 }
 
-export function isNewline(code): boolean {
+export function isNewline(code: any /** TODO #9100 */): boolean {
   switch (code) {
     case $FF:
     case $CR:
diff --git a/modules/@angular/compiler/src/css/parser.ts b/modules/@angular/compiler/src/css/parser.ts
index eff65cbe2c..6aefbd249f 100644
--- a/modules/@angular/compiler/src/css/parser.ts
+++ b/modules/@angular/compiler/src/css/parser.ts
@@ -181,8 +181,8 @@ export class CssParser {
   }
 
   /** @internal */
-  _parseStyleSheet(delimiters): CssStyleSheetAST {
-    var results = [];
+  _parseStyleSheet(delimiters: any /** TODO #9100 */): CssStyleSheetAST {
+    var results: any[] /** TODO #9100 */ = [];
     this._scanner.consumeEmptyStatements();
     while (this._scanner.peek != $EOF) {
       this._scanner.setMode(CssLexerMode.BLOCK);
@@ -208,7 +208,7 @@ export class CssParser {
     this._assertCondition(token.type == CssTokenType.AtKeyword,
                           `The CSS Rule ${token.strValue} is not a valid [@] rule.`, token);
 
-    var block, type = this._resolveBlockType(token);
+    var block: any /** TODO #9100 */, type = this._resolveBlockType(token);
     switch (type) {
       case BlockType.Charset:
       case BlockType.Namespace:
@@ -243,7 +243,7 @@ export class CssParser {
 
       // if a custom @rule { ... } is used it should still tokenize the insides
       default:
-        var listOfTokens = [];
+        var listOfTokens: any[] /** TODO #9100 */ = [];
         this._scanner.setMode(CssLexerMode.ALL);
         this._error(generateErrorMessage(
                         this._scanner.input,
@@ -276,7 +276,7 @@ export class CssParser {
   _parseSelectors(delimiters: number): CssSelectorAST[] {
     delimiters = bitWiseOr([delimiters, LBRACE_DELIM]);
 
-    var selectors = [];
+    var selectors: any[] /** TODO #9100 */ = [];
     var isParsingSelectors = true;
     while (isParsingSelectors) {
       selectors.push(this._parseSelector(delimiters));
@@ -321,7 +321,7 @@ export class CssParser {
 
     this._consume(CssTokenType.Character, '{');
 
-    var definitions = [];
+    var definitions: any[] /** TODO #9100 */ = [];
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       definitions.push(this._parseKeyframeDefinition(delimiters));
     }
@@ -333,7 +333,7 @@ export class CssParser {
 
   /** @internal */
   _parseKeyframeDefinition(delimiters: number): CssKeyframeDefinitionAST {
-    var stepTokens = [];
+    var stepTokens: any[] /** TODO #9100 */ = [];
     delimiters = bitWiseOr([delimiters, LBRACE_DELIM]);
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       stepTokens.push(this._parseKeyframeLabel(bitWiseOr([delimiters, COMMA_DELIM])));
@@ -357,11 +357,11 @@ export class CssParser {
     delimiters = bitWiseOr([delimiters, COMMA_DELIM, LBRACE_DELIM]);
     this._scanner.setMode(CssLexerMode.SELECTOR);
 
-    var selectorCssTokens = [];
+    var selectorCssTokens: any[] /** TODO #9100 */ = [];
     var isComplex = false;
-    var wsCssToken;
+    var wsCssToken: any /** TODO #9100 */;
 
-    var previousToken;
+    var previousToken: any /** TODO #9100 */;
     var parenCount = 0;
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       var code = this._scanner.peek;
@@ -454,10 +454,10 @@ export class CssParser {
     this._scanner.setMode(CssLexerMode.STYLE_VALUE);
 
     var strValue = "";
-    var tokens = [];
+    var tokens: any[] /** TODO #9100 */ = [];
     var previous: CssToken;
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
-      var token;
+      var token: any /** TODO #9100 */;
       if (isPresent(previous) && previous.type == CssTokenType.Identifier &&
           this._scanner.peek == $LPAREN) {
         token = this._consume(CssTokenType.Character, '(');
@@ -504,7 +504,7 @@ export class CssParser {
 
   /** @internal */
   _collectUntilDelim(delimiters: number, assertType: CssTokenType = null): CssToken[] {
-    var tokens = [];
+    var tokens: any[] /** TODO #9100 */ = [];
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       var val = isPresent(assertType) ? this._consume(assertType) : this._scan();
       tokens.push(val);
@@ -521,7 +521,7 @@ export class CssParser {
     this._consume(CssTokenType.Character, '{');
     this._scanner.consumeEmptyStatements();
 
-    var results = [];
+    var results: any[] /** TODO #9100 */ = [];
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       results.push(this._parseRule(delimiters));
     }
@@ -543,7 +543,7 @@ export class CssParser {
     this._consume(CssTokenType.Character, '{');
     this._scanner.consumeEmptyStatements();
 
-    var definitions = [];
+    var definitions: any[] /** TODO #9100 */ = [];
     while (!characterContainsDelimiter(this._scanner.peek, delimiters)) {
       definitions.push(this._parseDefinition(delimiters));
       this._scanner.consumeEmptyStatements();
@@ -562,7 +562,7 @@ export class CssParser {
     this._scanner.setMode(CssLexerMode.STYLE_BLOCK);
 
     var prop = this._consume(CssTokenType.Identifier);
-    var parseValue, value = null;
+    var parseValue: any /** TODO #9100 */, value: any /** TODO #9100 */ = null;
 
     // the colon value separates the prop from the style.
     // there are a few cases as to what could happen if it
@@ -655,7 +655,7 @@ export class CssKeyframeRuleAST extends CssBlockRuleAST {
 }
 
 export class CssKeyframeDefinitionAST extends CssBlockRuleAST {
-  public steps;
+  public steps: any /** TODO #9100 */;
   constructor(_steps: CssToken[], block: CssBlockAST) {
     super(BlockType.Keyframes, block, mergeTokens(_steps, ","));
     this.steps = _steps;
@@ -704,7 +704,7 @@ export class CssDefinitionAST extends CssAST {
 }
 
 export class CssSelectorAST extends CssAST {
-  public strValue;
+  public strValue: any /** TODO #9100 */;
   constructor(public tokens: CssToken[], public isComplex: boolean = false) {
     super();
     this.strValue = tokens.map(token => token.strValue).join("");
@@ -735,6 +735,6 @@ export class CssParseError extends ParseError {
 }
 
 export class CssUnknownTokenListAST extends CssRuleAST {
-  constructor(public name, public tokens: CssToken[]) { super(); }
+  constructor(public name: any /** TODO #9100 */, public tokens: CssToken[]) { super(); }
   visit(visitor: CssASTVisitor, context?: any) { visitor.visitUnkownRule(this, context); }
 }
diff --git a/modules/@angular/compiler/src/directive_lifecycle_reflector.ts b/modules/@angular/compiler/src/directive_lifecycle_reflector.ts
index db7db64c4f..26161701be 100644
--- a/modules/@angular/compiler/src/directive_lifecycle_reflector.ts
+++ b/modules/@angular/compiler/src/directive_lifecycle_reflector.ts
@@ -35,7 +35,7 @@ const LIFECYCLE_PROPS: Map<any, string> = MapWrapper.createFromPairs([
   [LifecycleHooks.AfterViewChecked, 'ngAfterViewChecked'],
 ]);
 
-export function hasLifecycleHook(hook: LifecycleHooks, token): boolean {
+export function hasLifecycleHook(hook: LifecycleHooks, token: any /** TODO #9100 */): boolean {
   var lcInterface = LIFECYCLE_INTERFACES.get(hook);
   var lcProp = LIFECYCLE_PROPS.get(hook);
   return reflector.hasLifecycleHook(token, lcInterface, lcProp);
diff --git a/modules/@angular/compiler/src/directive_resolver.ts b/modules/@angular/compiler/src/directive_resolver.ts
index 19174373d6..ba17776f9c 100644
--- a/modules/@angular/compiler/src/directive_resolver.ts
+++ b/modules/@angular/compiler/src/directive_resolver.ts
@@ -61,8 +61,8 @@ export class DirectiveResolver {
   private _mergeWithPropertyMetadata(dm: DirectiveMetadata,
                                      propertyMetadata: {[key: string]: any[]},
                                      directiveType: Type): DirectiveMetadata {
-    var inputs = [];
-    var outputs = [];
+    var inputs: any[] /** TODO #9100 */ = [];
+    var outputs: any[] /** TODO #9100 */ = [];
     var host: {[key: string]: string} = {};
     var queries: {[key: string]: any} = {};
 
@@ -122,7 +122,7 @@ export class DirectiveResolver {
                  directiveType: Type): DirectiveMetadata {
     var mergedInputs = isPresent(dm.inputs) ? ListWrapper.concat(dm.inputs, inputs) : inputs;
 
-    var mergedOutputs;
+    var mergedOutputs: any /** TODO #9100 */;
     if (isPresent(dm.outputs)) {
       dm.outputs.forEach((propName: string) => {
         if (ListWrapper.contains(outputs, propName)) {
diff --git a/modules/@angular/compiler/src/expression_parser/ast.ts b/modules/@angular/compiler/src/expression_parser/ast.ts
index 445e9edfbc..effb6fbc2e 100644
--- a/modules/@angular/compiler/src/expression_parser/ast.ts
+++ b/modules/@angular/compiler/src/expression_parser/ast.ts
@@ -94,7 +94,7 @@ export class BindingPipe extends AST {
 }
 
 export class LiteralPrimitive extends AST {
-  constructor(public value) { super(); }
+  constructor(public value: any /** TODO #9100 */) { super(); }
   visit(visitor: AstVisitor, context: any = null): any {
     return visitor.visitLiteralPrimitive(this, context);
   }
diff --git a/modules/@angular/compiler/src/expression_parser/lexer.ts b/modules/@angular/compiler/src/expression_parser/lexer.ts
index b6578f05a6..13907563a0 100644
--- a/modules/@angular/compiler/src/expression_parser/lexer.ts
+++ b/modules/@angular/compiler/src/expression_parser/lexer.ts
@@ -16,7 +16,7 @@ export enum TokenType {
 export class Lexer {
   tokenize(text: string): any[] {
     var scanner = new _Scanner(text);
-    var tokens = [];
+    var tokens: any[] /** TODO #9100 */ = [];
     var token = scanner.scanToken();
     while (token != null) {
       tokens.push(token);
@@ -160,7 +160,7 @@ export const $RBRACE = /*@ts2dart_const*/ 125;
 const $NBSP = /*@ts2dart_const*/ 160;
 
 export class ScannerError extends BaseException {
-  constructor(public message) { super(); }
+  constructor(public message: any /** TODO #9100 */) { super(); }
 
   toString(): string { return this.message; }
 }
diff --git a/modules/@angular/compiler/src/expression_parser/parser.ts b/modules/@angular/compiler/src/expression_parser/parser.ts
index cce424c7b4..347cde7b67 100644
--- a/modules/@angular/compiler/src/expression_parser/parser.ts
+++ b/modules/@angular/compiler/src/expression_parser/parser.ts
@@ -125,7 +125,7 @@ export class Parser {
     let split = this.splitInterpolation(input, location);
     if (split == null) return null;
 
-    let expressions = [];
+    let expressions: any[] /** TODO #9100 */ = [];
 
     for (let i = 0; i < split.expressions.length; ++i) {
       var tokens = this._lexer.tokenize(this._stripComments(split.expressions[i]));
@@ -141,8 +141,8 @@ export class Parser {
     if (parts.length <= 1) {
       return null;
     }
-    var strings = [];
-    var expressions = [];
+    var strings: any[] /** TODO #9100 */ = [];
+    var expressions: any[] /** TODO #9100 */ = [];
 
     for (var i = 0; i < parts.length; i++) {
       var part: string = parts[i];
@@ -170,7 +170,7 @@ export class Parser {
   }
 
   private _commentStart(input: string): number {
-    var outerQuote = null;
+    var outerQuote: any /** TODO #9100 */ = null;
     for (var i = 0; i < input.length - 1; i++) {
       let char = StringWrapper.charCodeAt(input, i);
       let nextChar = StringWrapper.charCodeAt(input, i + 1);
@@ -277,7 +277,7 @@ export class _ParseAST {
   }
 
   parseChain(): AST {
-    var exprs = [];
+    var exprs: any[] /** TODO #9100 */ = [];
     while (this.index < this.tokens.length) {
       var expr = this.parsePipe();
       exprs.push(expr);
@@ -306,7 +306,7 @@ export class _ParseAST {
 
       do {
         var name = this.expectIdentifierOrKeyword();
-        var args = [];
+        var args: any[] /** TODO #9100 */ = [];
         while (this.optionalCharacter($COLON)) {
           args.push(this.parseExpression());
         }
@@ -512,7 +512,7 @@ export class _ParseAST {
   }
 
   parseExpressionList(terminator: number): any[] {
-    var result = [];
+    var result: any[] /** TODO #9100 */ = [];
     if (!this.next.isCharacter(terminator)) {
       do {
         result.push(this.parsePipe());
@@ -522,8 +522,8 @@ export class _ParseAST {
   }
 
   parseLiteralMap(): LiteralMap {
-    var keys = [];
-    var values = [];
+    var keys: any[] /** TODO #9100 */ = [];
+    var values: any[] /** TODO #9100 */ = [];
     this.expectCharacter($LBRACE);
     if (!this.optionalCharacter($RBRACE)) {
       do {
@@ -571,7 +571,7 @@ export class _ParseAST {
 
   parseCallArguments(): BindingPipe[] {
     if (this.next.isCharacter($RPAREN)) return [];
-    var positionals = [];
+    var positionals: any[] /** TODO #9100 */ = [];
     do {
       positionals.push(this.parsePipe());
     } while (this.optionalCharacter($COMMA));
@@ -582,7 +582,7 @@ export class _ParseAST {
     if (!this.parseAction) {
       this.error("Binding expression cannot contain chained expression");
     }
-    var exprs = [];
+    var exprs: any[] /** TODO #9100 */ = [];
     while (this.index < this.tokens.length && !this.next.isCharacter($RBRACE)) {
       var expr = this.parseExpression();
       exprs.push(expr);
@@ -618,7 +618,7 @@ export class _ParseAST {
 
   parseTemplateBindings(): TemplateBindingParseResult {
     var bindings: TemplateBinding[] = [];
-    var prefix = null;
+    var prefix: any /** TODO #9100 */ = null;
     var warnings: string[] = [];
     while (this.index < this.tokens.length) {
       var keyIsVar: boolean = this.peekKeywordLet();
@@ -642,8 +642,8 @@ export class _ParseAST {
         }
       }
       this.optionalCharacter($COLON);
-      var name = null;
-      var expression = null;
+      var name: any /** TODO #9100 */ = null;
+      var expression: any /** TODO #9100 */ = null;
       if (keyIsVar) {
         if (this.optionalOperator("=")) {
           name = this.expectTemplateBindingKey();
diff --git a/modules/@angular/compiler/src/html_ast.ts b/modules/@angular/compiler/src/html_ast.ts
index ad354a14c2..493c4a3a87 100644
--- a/modules/@angular/compiler/src/html_ast.ts
+++ b/modules/@angular/compiler/src/html_ast.ts
@@ -57,7 +57,7 @@ export interface HtmlAstVisitor {
 }
 
 export function htmlVisitAll(visitor: HtmlAstVisitor, asts: HtmlAst[], context: any = null): any[] {
-  var result = [];
+  var result: any[] /** TODO #9100 */ = [];
   asts.forEach(ast => {
     var astResult = ast.visit(visitor, context);
     if (isPresent(astResult)) {
diff --git a/modules/@angular/compiler/src/html_lexer.ts b/modules/@angular/compiler/src/html_lexer.ts
index 1c063539d8..74baa2e581 100644
--- a/modules/@angular/compiler/src/html_lexer.ts
+++ b/modules/@angular/compiler/src/html_lexer.ts
@@ -118,7 +118,7 @@ class _HtmlTokenizer {
   private currentTokenStart: ParseLocation;
   private currentTokenType: HtmlTokenType;
 
-  private expansionCaseStack = [];
+  private expansionCaseStack: any[] /** TODO #9100 */ = [];
 
   tokens: HtmlToken[] = [];
   errors: HtmlTokenError[] = [];
@@ -357,7 +357,7 @@ class _HtmlTokenizer {
       }
       this._advance();
       let name = this.input.substring(start.offset + 1, this.index - 1);
-      let char = NAMED_ENTITIES[name];
+      let char = (NAMED_ENTITIES as any /** TODO #9100 */)[name];
       if (isBlank(char)) {
         throw this._createError(unknownEntityErrorMsg(name), this._getSpan(start));
       }
@@ -367,11 +367,11 @@ class _HtmlTokenizer {
 
   private _consumeRawText(decodeEntities: boolean, firstCharOfEnd: number,
                           attemptEndRest: Function): HtmlToken {
-    var tagCloseStart;
+    var tagCloseStart: any /** TODO #9100 */;
     var textStart = this._getLocation();
     this._beginToken(decodeEntities ? HtmlTokenType.ESCAPABLE_RAW_TEXT : HtmlTokenType.RAW_TEXT,
                      textStart);
-    var parts = [];
+    var parts: any[] /** TODO #9100 */ = [];
     while (true) {
       tagCloseStart = this._getLocation();
       if (this._attemptCharCode(firstCharOfEnd) && attemptEndRest()) {
@@ -414,11 +414,11 @@ class _HtmlTokenizer {
 
   private _consumePrefixAndName(): string[] {
     var nameOrPrefixStart = this.index;
-    var prefix = null;
+    var prefix: any /** TODO #9100 */ = null;
     while (this.peek !== $COLON && !isPrefixEnd(this.peek)) {
       this._advance();
     }
-    var nameStart;
+    var nameStart: any /** TODO #9100 */;
     if (this.peek === $COLON) {
       this._advance();
       prefix = this.input.substring(nameOrPrefixStart, this.index - 1);
@@ -433,7 +433,7 @@ class _HtmlTokenizer {
 
   private _consumeTagOpen(start: ParseLocation) {
     let savedPos = this._savePosition();
-    let lowercaseTagName;
+    let lowercaseTagName: any /** TODO #9100 */;
     try {
       if (!isAsciiLetter(this.peek)) {
         throw this._createError(unexpectedCharacterErrorMsg(this.peek), this._getSpan());
@@ -500,11 +500,11 @@ class _HtmlTokenizer {
 
   private _consumeAttributeValue() {
     this._beginToken(HtmlTokenType.ATTR_VALUE);
-    var value;
+    var value: any /** TODO #9100 */;
     if (this.peek === $SQ || this.peek === $DQ) {
       var quoteChar = this.peek;
       this._advance();
-      var parts = [];
+      var parts: any[] /** TODO #9100 */ = [];
       while (this.peek !== quoteChar) {
         parts.push(this._readChar(true));
       }
@@ -529,7 +529,7 @@ class _HtmlTokenizer {
   private _consumeTagClose(start: ParseLocation) {
     this._beginToken(HtmlTokenType.TAG_CLOSE, start);
     this._attemptCharCodeUntilFn(isNotWhitespace);
-    var prefixAndName;
+    var prefixAndName: any /** TODO #9100 */;
     prefixAndName = this._consumePrefixAndName();
     this._attemptCharCodeUntilFn(isNotWhitespace);
     this._requireCharCode($GT);
@@ -593,7 +593,7 @@ class _HtmlTokenizer {
     var start = this._getLocation();
     this._beginToken(HtmlTokenType.TEXT, start);
 
-    var parts = [];
+    var parts: any[] /** TODO #9100 */ = [];
     let interpolation = false;
 
     if (this.peek === $LBRACE && this.nextPeek === $LBRACE) {
@@ -712,7 +712,7 @@ function toUpperCaseCharCode(code: number): number {
 }
 
 function mergeTextTokens(srcTokens: HtmlToken[]): HtmlToken[] {
-  let dstTokens = [];
+  let dstTokens: any[] /** TODO #9100 */ = [];
   let lastDstToken: HtmlToken;
   for (let i = 0; i < srcTokens.length; i++) {
     let token = srcTokens[i];
diff --git a/modules/@angular/compiler/src/html_parser.ts b/modules/@angular/compiler/src/html_parser.ts
index 141b6f94b3..2c5ca1a768 100644
--- a/modules/@angular/compiler/src/html_parser.ts
+++ b/modules/@angular/compiler/src/html_parser.ts
@@ -115,7 +115,7 @@ class TreeBuilder {
     let switchValue = this._advance();
 
     let type = this._advance();
-    let cases = [];
+    let cases: any[] /** TODO #9100 */ = [];
 
     // read =
     while (this.peek.type === HtmlTokenType.EXPANSION_CASE_VALUE) {
@@ -170,7 +170,7 @@ class TreeBuilder {
   }
 
   private _collectExpansionExpTokens(start: HtmlToken): HtmlToken[] {
-    let exp = [];
+    let exp: any[] /** TODO #9100 */ = [];
     let expansionFormStack = [HtmlTokenType.EXPANSION_CASE_EXP_START];
 
     while (true) {
@@ -239,7 +239,7 @@ class TreeBuilder {
   private _consumeStartTag(startTagToken: HtmlToken) {
     var prefix = startTagToken.parts[0];
     var name = startTagToken.parts[1];
-    var attrs = [];
+    var attrs: any[] /** TODO #9100 */ = [];
     while (this.peek.type === HtmlTokenType.ATTR_NAME) {
       attrs.push(this._consumeAttr(this._advance()));
     }
diff --git a/modules/@angular/compiler/src/i18n/i18n_html_parser.ts b/modules/@angular/compiler/src/i18n/i18n_html_parser.ts
index b167ad0dde..29ded6733b 100644
--- a/modules/@angular/compiler/src/i18n/i18n_html_parser.ts
+++ b/modules/@angular/compiler/src/i18n/i18n_html_parser.ts
@@ -279,14 +279,14 @@ export class I18nHtmlParser implements HtmlParser {
   }
 
   private _i18nAttributes(el: HtmlElementAst): HtmlAttrAst[] {
-    let res = [];
+    let res: any[] /** TODO #9100 */ = [];
     let implicitAttrs: string[] =
         isPresent(this._implicitAttrs[el.name]) ? this._implicitAttrs[el.name] : [];
 
     el.attrs.forEach(attr => {
       if (attr.name.startsWith(I18N_ATTR_PREFIX) || attr.name == I18N_ATTR) return;
 
-      let message;
+      let message: any /** TODO #9100 */;
 
       let i18ns = el.attrs.filter(a => a.name == `${I18N_ATTR_PREFIX}${attr.name}`);
 
@@ -333,7 +333,7 @@ export class I18nHtmlParser implements HtmlParser {
   private _replacePlaceholdersWithExpressions(message: string, exps: string[],
                                               sourceSpan: ParseSourceSpan): string {
     let expMap = this._buildExprMap(exps);
-    return RegExpWrapper.replaceAll(_PLACEHOLDER_EXPANDED_REGEXP, message, (match) => {
+    return RegExpWrapper.replaceAll(_PLACEHOLDER_EXPANDED_REGEXP, message, (match: any /** TODO #9100 */) => {
       let nameWithQuotes = match[2];
       let name = nameWithQuotes.substring(1, nameWithQuotes.length - 1);
       return this._convertIntoExpression(name, expMap, sourceSpan);
diff --git a/modules/@angular/compiler/src/i18n/shared.ts b/modules/@angular/compiler/src/i18n/shared.ts
index 7418543896..135977a2c9 100644
--- a/modules/@angular/compiler/src/i18n/shared.ts
+++ b/modules/@angular/compiler/src/i18n/shared.ts
@@ -28,11 +28,11 @@ export class I18nError extends ParseError {
 
 // Man, this is so ugly!
 export function partition(nodes: HtmlAst[], errors: ParseError[], implicitTags: string[]): Part[] {
-  let res = [];
+  let res: any[] /** TODO #9100 */ = [];
 
   for (let i = 0; i < nodes.length; ++i) {
     let n = nodes[i];
-    let temp = [];
+    let temp: any[] /** TODO #9100 */ = [];
     if (_isOpeningComment(n)) {
       let i18n = (<HtmlCommentAst>n).value.substring(5).trim();
       i++;
diff --git a/modules/@angular/compiler/src/i18n/xmb_serializer.ts b/modules/@angular/compiler/src/i18n/xmb_serializer.ts
index 351751de73..20a672130e 100644
--- a/modules/@angular/compiler/src/i18n/xmb_serializer.ts
+++ b/modules/@angular/compiler/src/i18n/xmb_serializer.ts
@@ -38,7 +38,7 @@ export function deserializeXmb(content: string, url: string): XmbDeserialization
   }
 
   let bundleEl = <HtmlElementAst>parsed.rootNodes[0];  // test this
-  let errors = [];
+  let errors: any[] /** TODO #9100 */ = [];
   let messages: {[key: string]: HtmlAst[]} = {};
 
   _createMessages(bundleEl.children, messages, errors);
@@ -88,7 +88,7 @@ function _serializeMessage(m: Message): string {
 }
 
 function _expandPlaceholder(input: string): string {
-  return RegExpWrapper.replaceAll(_PLACEHOLDER_REGEXP, input, (match) => {
+  return RegExpWrapper.replaceAll(_PLACEHOLDER_REGEXP, input, (match: any /** TODO #9100 */) => {
     let nameWithQuotes = match[2];
     return `<ph name=${nameWithQuotes}></ph>`;
   });
diff --git a/modules/@angular/compiler/src/metadata_resolver.ts b/modules/@angular/compiler/src/metadata_resolver.ts
index cc98cadaaf..1e1f22a245 100644
--- a/modules/@angular/compiler/src/metadata_resolver.ts
+++ b/modules/@angular/compiler/src/metadata_resolver.ts
@@ -126,9 +126,9 @@ export class CompileMetadataResolver {
     var meta = this._directiveCache.get(directiveType);
     if (isBlank(meta)) {
       var dirMeta = this._directiveResolver.resolve(directiveType);
-      var templateMeta = null;
-      var changeDetectionStrategy = null;
-      var viewProviders = [];
+      var templateMeta: any /** TODO #9100 */ = null;
+      var changeDetectionStrategy: any /** TODO #9100 */ = null;
+      var viewProviders: any[] /** TODO #9100 */ = [];
       var moduleUrl = staticTypeModuleUrl(directiveType);
       if (dirMeta instanceof ComponentMetadata) {
         assertArrayOfStrings('styles', dirMeta.styles);
@@ -154,12 +154,12 @@ export class CompileMetadataResolver {
         moduleUrl = componentModuleUrl(this._reflector, directiveType, cmpMeta);
       }
 
-      var providers = [];
+      var providers: any[] /** TODO #9100 */ = [];
       if (isPresent(dirMeta.providers)) {
         providers = this.getProvidersMetadata(dirMeta.providers);
       }
-      var queries = [];
-      var viewQueries = [];
+      var queries: any[] /** TODO #9100 */ = [];
+      var viewQueries: any[] /** TODO #9100 */ = [];
       if (isPresent(dirMeta.queries)) {
         queries = this.getQueriesMetadata(dirMeta.queries, false, directiveType);
         viewQueries = this.getQueriesMetadata(dirMeta.queries, true, directiveType);
@@ -275,7 +275,7 @@ export class CompileMetadataResolver {
       let isOptional = false;
       let query: QueryMetadata = null;
       let viewQuery: ViewQueryMetadata = null;
-      var token = null;
+      var token: any /** TODO #9100 */ = null;
       if (isArray(param)) {
         (<any[]>param)
             .forEach((paramEntry) => {
@@ -324,7 +324,7 @@ export class CompileMetadataResolver {
 
   getTokenMetadata(token: any): cpl.CompileTokenMetadata {
     token = resolveForwardRef(token);
-    var compileToken;
+    var compileToken: any /** TODO #9100 */;
     if (isString(token)) {
       compileToken = new cpl.CompileTokenMetadata({value: token});
     } else {
@@ -356,7 +356,7 @@ export class CompileMetadataResolver {
   }
 
   getProviderMetadata(provider: Provider): cpl.CompileProviderMetadata {
-    var compileDeps;
+    var compileDeps: any /** TODO #9100 */;
     if (isPresent(provider.useClass)) {
       compileDeps = this.getDependenciesMetadata(provider.useClass, provider.dependencies);
     } else if (isPresent(provider.useFactory)) {
@@ -382,8 +382,8 @@ export class CompileMetadataResolver {
 
   getQueriesMetadata(queries: {[key: string]: QueryMetadata},
                      isViewQuery: boolean, directiveType: Type): cpl.CompileQueryMetadata[] {
-    var compileQueries = [];
-    StringMapWrapper.forEach(queries, (query, propertyName) => {
+    var compileQueries: any[] /** TODO #9100 */ = [];
+    StringMapWrapper.forEach(queries, (query: any /** TODO #9100 */, propertyName: any /** TODO #9100 */) => {
       if (query.isViewQuery === isViewQuery) {
         compileQueries.push(this.getQueryMetadata(query, propertyName, directiveType));
       }
@@ -392,7 +392,7 @@ export class CompileMetadataResolver {
   }
 
   getQueryMetadata(q: QueryMetadata, propertyName: string, typeOrFunc: Type | Function): cpl.CompileQueryMetadata {
-    var selectors;
+    var selectors: any /** TODO #9100 */;
     if (q.isVarBindingQuery) {
       selectors = q.varBindings.map(varName => this.getTokenMetadata(varName));
     } else {
@@ -412,7 +412,7 @@ export class CompileMetadataResolver {
 }
 
 function flattenDirectives(view: ViewMetadata, platformDirectives: any[]): Type[] {
-  let directives = [];
+  let directives: any[] /** TODO #9100 */ = [];
   if (isPresent(platformDirectives)) {
     flattenArray(platformDirectives, directives);
   }
@@ -423,7 +423,7 @@ function flattenDirectives(view: ViewMetadata, platformDirectives: any[]): Type[
 }
 
 function flattenPipes(view: ViewMetadata, platformPipes: any[]): Type[] {
-  let pipes = [];
+  let pipes: any[] /** TODO #9100 */ = [];
   if (isPresent(platformPipes)) {
     flattenArray(platformPipes, pipes);
   }
diff --git a/modules/@angular/compiler/src/offline_compiler.ts b/modules/@angular/compiler/src/offline_compiler.ts
index e6218de861..4538e7785d 100644
--- a/modules/@angular/compiler/src/offline_compiler.ts
+++ b/modules/@angular/compiler/src/offline_compiler.ts
@@ -53,8 +53,8 @@ export class OfflineCompiler {
     if (components.length === 0) {
       throw new BaseException('No components given');
     }
-    var statements = [];
-    var exportedVars = [];
+    var statements: any[] /** TODO #9100 */ = [];
+    var exportedVars: any[] /** TODO #9100 */ = [];
     var moduleUrl = _templateModuleUrl(components[0].component);
     components.forEach(componentWithDirs => {
       var compMeta = <CompileDirectiveMetadata>componentWithDirs.component;
@@ -88,7 +88,7 @@ export class OfflineCompiler {
     return this._xhr.get(stylesheetUrl)
         .then((cssText) => {
           var compileResult = this._styleCompiler.compileStylesheet(stylesheetUrl, cssText, shim);
-          var importedUrls = [];
+          var importedUrls: any[] /** TODO #9100 */ = [];
           compileResult.dependencies.forEach((dep) => {
             importedUrls.push(dep.moduleUrl);
             dep.valuePlaceholder.moduleUrl = _stylesModuleUrl(dep.moduleUrl, dep.isShimmed, suffix);
diff --git a/modules/@angular/compiler/src/output/abstract_emitter.ts b/modules/@angular/compiler/src/output/abstract_emitter.ts
index 41d82add9a..a1e0082bbb 100644
--- a/modules/@angular/compiler/src/output/abstract_emitter.ts
+++ b/modules/@angular/compiler/src/output/abstract_emitter.ts
@@ -274,7 +274,7 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
   abstract visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: any): any;
 
   visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, ctx: EmitterVisitorContext): any {
-    var opStr;
+    var opStr: any /** TODO #9100 */;
     switch (ast.operator) {
       case o.BinaryOperator.Equals:
         opStr = '==';
@@ -358,7 +358,7 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
     var useNewLine = ast.entries.length > 1;
     ctx.print(`{`, useNewLine);
     ctx.incIndent();
-    this.visitAllObjects((entry) => {
+    this.visitAllObjects((entry: any /** TODO #9100 */) => {
       ctx.print(`${escapeSingleQuoteString(entry[0], this._escapeDollarInStrings)}: `);
       entry[1].visitExpression(this, ctx);
     }, ast.entries, ctx, ',', useNewLine);
@@ -369,7 +369,7 @@ export abstract class AbstractEmitterVisitor implements o.StatementVisitor, o.Ex
 
   visitAllExpressions(expressions: o.Expression[], ctx: EmitterVisitorContext, separator: string,
                       newLine: boolean = false): void {
-    this.visitAllObjects((expr) => expr.visitExpression(this, ctx), expressions, ctx, separator,
+    this.visitAllObjects((expr: any /** TODO #9100 */) => expr.visitExpression(this, ctx), expressions, ctx, separator,
                          newLine);
   }
 
@@ -395,7 +395,7 @@ export function escapeSingleQuoteString(input: string, escapeDollar: boolean): a
   if (isBlank(input)) {
     return null;
   }
-  var body = StringWrapper.replaceAllMapped(input, _SINGLE_QUOTE_ESCAPE_STRING_RE, (match) => {
+  var body = StringWrapper.replaceAllMapped(input, _SINGLE_QUOTE_ESCAPE_STRING_RE, (match: any /** TODO #9100 */) => {
     if (match[0] == '$') {
       return escapeDollar ? '\\$' : '$';
     } else if (match[0] == '\n') {
diff --git a/modules/@angular/compiler/src/output/abstract_js_emitter.ts b/modules/@angular/compiler/src/output/abstract_js_emitter.ts
index 7b52117b5e..c3ec39c951 100644
--- a/modules/@angular/compiler/src/output/abstract_js_emitter.ts
+++ b/modules/@angular/compiler/src/output/abstract_js_emitter.ts
@@ -141,11 +141,11 @@ export abstract class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
   }
 
   private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => ctx.print(param.name), params, ctx, ',');
+    this.visitAllObjects((param: any /** TODO #9100 */) => ctx.print(param.name), params, ctx, ',');
   }
 
   getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
+    var name: any /** TODO #9100 */;
     switch (method) {
       case o.BuiltinMethod.ConcatArray:
         name = 'concat';
diff --git a/modules/@angular/compiler/src/output/dart_emitter.ts b/modules/@angular/compiler/src/output/dart_emitter.ts
index 1fa41ea759..f004dc8a5a 100644
--- a/modules/@angular/compiler/src/output/dart_emitter.ts
+++ b/modules/@angular/compiler/src/output/dart_emitter.ts
@@ -39,7 +39,7 @@ export function debugOutputAstAsDart(ast: o.Statement | o.Expression | o.Type |
 export class DartEmitter implements OutputEmitter {
   constructor(private _importGenerator: ImportGenerator) {}
   emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
-    var srcParts = [];
+    var srcParts: any[] /** TODO #9100 */ = [];
     // Note: We are not creating a library here as Dart does not need it.
     // Dart analzyer might complain about it though.
 
@@ -195,7 +195,7 @@ class _DartEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisito
   }
 
   getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
+    var name: any /** TODO #9100 */;
     switch (method) {
       case o.BuiltinMethod.ConcatArray:
         name = '.addAll';
@@ -271,7 +271,7 @@ class _DartEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisito
     return null;
   }
   visitBuiltintType(type: o.BuiltinType, ctx: EmitterVisitorContext): any {
-    var typeStr;
+    var typeStr: any /** TODO #9100 */;
     switch (type.name) {
       case o.BuiltinTypeName.Bool:
         typeStr = 'bool';
@@ -323,7 +323,7 @@ class _DartEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisito
   }
 
   private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => {
+    this.visitAllObjects((param: any /** TODO #9100 */) => {
       if (isPresent(param.type)) {
         param.type.visitType(this, ctx);
         ctx.print(' ');
@@ -348,7 +348,7 @@ class _DartEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisito
     ctx.print(value.name);
     if (isPresent(typeParams) && typeParams.length > 0) {
       ctx.print(`<`);
-      this.visitAllObjects((type) => type.visitType(this, ctx), typeParams, ctx, ',');
+      this.visitAllObjects((type: any /** TODO #9100 */) => type.visitType(this, ctx), typeParams, ctx, ',');
       ctx.print(`>`);
     }
   }
diff --git a/modules/@angular/compiler/src/output/dart_imports.ts b/modules/@angular/compiler/src/output/dart_imports.ts
index 3b51bd42f0..d690927935 100644
--- a/modules/@angular/compiler/src/output/dart_imports.ts
+++ b/modules/@angular/compiler/src/output/dart_imports.ts
@@ -31,7 +31,7 @@ export function getRelativePath(modulePath: string, importedPath: string): strin
   var importedParts = importedPath.split(_PATH_SEP_RE);
   var longestPrefix = getLongestPathSegmentPrefix(moduleParts, importedParts);
 
-  var resultParts = [];
+  var resultParts: any[] /** TODO #9100 */ = [];
   var goParentCount = moduleParts.length - 1 - longestPrefix;
   for (var i = 0; i < goParentCount; i++) {
     resultParts.push('..');
diff --git a/modules/@angular/compiler/src/output/js_emitter.ts b/modules/@angular/compiler/src/output/js_emitter.ts
index 55bdb0d050..e9c713e640 100644
--- a/modules/@angular/compiler/src/output/js_emitter.ts
+++ b/modules/@angular/compiler/src/output/js_emitter.ts
@@ -18,7 +18,7 @@ export class JavaScriptEmitter implements OutputEmitter {
     var converter = new JsEmitterVisitor(moduleUrl);
     var ctx = EmitterVisitorContext.createRoot(exportedVars);
     converter.visitAllStatements(stmts, ctx);
-    var srcParts = [];
+    var srcParts: any[] /** TODO #9100 */ = [];
     converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
       // Note: can't write the real word for import as it screws up system.js auto detection...
       srcParts.push(
diff --git a/modules/@angular/compiler/src/output/output_ast.ts b/modules/@angular/compiler/src/output/output_ast.ts
index c09e356d0b..3a227a009e 100644
--- a/modules/@angular/compiler/src/output/output_ast.ts
+++ b/modules/@angular/compiler/src/output/output_ast.ts
@@ -179,7 +179,7 @@ export enum BuiltinVar {
 }
 
 export class ReadVarExpr extends Expression {
-  public name;
+  public name: any /** TODO #9100 */;
   public builtin: BuiltinVar;
 
   constructor(name: string | BuiltinVar, type: Type = null) {
diff --git a/modules/@angular/compiler/src/output/output_interpreter.ts b/modules/@angular/compiler/src/output/output_interpreter.ts
index 2c9fe8378b..67e8cf159d 100644
--- a/modules/@angular/compiler/src/output/output_interpreter.ts
+++ b/modules/@angular/compiler/src/output/output_interpreter.ts
@@ -172,7 +172,7 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
   visitInvokeMethodExpr(expr: o.InvokeMethodExpr, ctx: _ExecutionContext): any {
     var receiver = expr.receiver.visitExpression(this, ctx);
     var args = this.visitAllExpressions(expr.args, ctx);
-    var result;
+    var result: any /** TODO #9100 */;
     if (isPresent(expr.builtin)) {
       switch (expr.builtin) {
         case o.BuiltinMethod.ConcatArray:
@@ -324,7 +324,7 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
     }
   }
   visitReadPropExpr(ast: o.ReadPropExpr, ctx: _ExecutionContext): any {
-    var result;
+    var result: any /** TODO #9100 */;
     var receiver = ast.receiver.visitExpression(this, ctx);
     if (isDynamicInstance(receiver)) {
       var di = <DynamicInstance>receiver;
@@ -352,7 +352,7 @@ class StatementInterpreter implements o.StatementVisitor, o.ExpressionVisitor {
   }
   visitLiteralMapExpr(ast: o.LiteralMapExpr, ctx: _ExecutionContext): any {
     var result = {};
-    ast.entries.forEach((entry) => result[<string>entry[0]] =
+    ast.entries.forEach((entry) => (result as any /** TODO #9100 */)[<string>entry[0]] =
                             (<o.Expression>entry[1]).visitExpression(this, ctx));
     return result;
   }
@@ -379,32 +379,32 @@ function _declareFn(varNames: string[], statements: o.Statement[], ctx: _Executi
     case 0:
       return () => _executeFunctionStatements(varNames, [], statements, ctx, visitor);
     case 1:
-      return (d0) => _executeFunctionStatements(varNames, [d0], statements, ctx, visitor);
+      return (d0: any /** TODO #9100 */) => _executeFunctionStatements(varNames, [d0], statements, ctx, visitor);
     case 2:
-      return (d0, d1) => _executeFunctionStatements(varNames, [d0, d1], statements, ctx, visitor);
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */) => _executeFunctionStatements(varNames, [d0, d1], statements, ctx, visitor);
     case 3:
-      return (d0, d1, d2) =>
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */) =>
                  _executeFunctionStatements(varNames, [d0, d1, d2], statements, ctx, visitor);
     case 4:
-      return (d0, d1, d2, d3) =>
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */) =>
                  _executeFunctionStatements(varNames, [d0, d1, d2, d3], statements, ctx, visitor);
     case 5:
-      return (d0, d1, d2, d3, d4) => _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4],
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */) => _executeFunctionStatements(varNames, [d0, d1, d2, d3, d4],
                                                                 statements, ctx, visitor);
     case 6:
-      return (d0, d1, d2, d3, d4, d5) => _executeFunctionStatements(
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */, d5: any /** TODO #9100 */) => _executeFunctionStatements(
                  varNames, [d0, d1, d2, d3, d4, d5], statements, ctx, visitor);
     case 7:
-      return (d0, d1, d2, d3, d4, d5, d6) => _executeFunctionStatements(
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */, d5: any /** TODO #9100 */, d6: any /** TODO #9100 */) => _executeFunctionStatements(
                  varNames, [d0, d1, d2, d3, d4, d5, d6], statements, ctx, visitor);
     case 8:
-      return (d0, d1, d2, d3, d4, d5, d6, d7) => _executeFunctionStatements(
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */, d5: any /** TODO #9100 */, d6: any /** TODO #9100 */, d7: any /** TODO #9100 */) => _executeFunctionStatements(
                  varNames, [d0, d1, d2, d3, d4, d5, d6, d7], statements, ctx, visitor);
     case 9:
-      return (d0, d1, d2, d3, d4, d5, d6, d7, d8) => _executeFunctionStatements(
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */, d5: any /** TODO #9100 */, d6: any /** TODO #9100 */, d7: any /** TODO #9100 */, d8: any /** TODO #9100 */) => _executeFunctionStatements(
                  varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8], statements, ctx, visitor);
     case 10:
-      return (d0, d1, d2, d3, d4, d5, d6, d7, d8, d9) => _executeFunctionStatements(
+      return (d0: any /** TODO #9100 */, d1: any /** TODO #9100 */, d2: any /** TODO #9100 */, d3: any /** TODO #9100 */, d4: any /** TODO #9100 */, d5: any /** TODO #9100 */, d6: any /** TODO #9100 */, d7: any /** TODO #9100 */, d8: any /** TODO #9100 */, d9: any /** TODO #9100 */) => _executeFunctionStatements(
                  varNames, [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], statements, ctx, visitor);
     default:
       throw new BaseException(
diff --git a/modules/@angular/compiler/src/output/output_jit.ts b/modules/@angular/compiler/src/output/output_jit.ts
index 90a55a0f3c..c1873040ba 100644
--- a/modules/@angular/compiler/src/output/output_jit.ts
+++ b/modules/@angular/compiler/src/output/output_jit.ts
@@ -22,7 +22,7 @@ class JitEmitterVisitor extends AbstractJsEmitterVisitor {
   getArgs(): {[key: string]: any} {
     var result = {};
     for (var i = 0; i < this._evalArgNames.length; i++) {
-      result[this._evalArgNames[i]] = this._evalArgValues[i];
+      (result as any /** TODO #9100 */)[this._evalArgNames[i]] = this._evalArgValues[i];
     }
     return result;
   }
diff --git a/modules/@angular/compiler/src/output/ts_emitter.ts b/modules/@angular/compiler/src/output/ts_emitter.ts
index cfbc0f8616..b5a30fc01d 100644
--- a/modules/@angular/compiler/src/output/ts_emitter.ts
+++ b/modules/@angular/compiler/src/output/ts_emitter.ts
@@ -43,7 +43,7 @@ export class TypeScriptEmitter implements OutputEmitter {
     var converter = new _TsEmitterVisitor(moduleUrl);
     var ctx = EmitterVisitorContext.createRoot(exportedVars);
     converter.visitAllStatements(stmts, ctx);
-    var srcParts = [];
+    var srcParts: any[] /** TODO #9100 */ = [];
     converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
       // Note: can't write the real word for import as it screws up system.js auto detection...
       srcParts.push(
@@ -208,7 +208,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
   }
 
   visitBuiltintType(type: o.BuiltinType, ctx: EmitterVisitorContext): any {
-    var typeStr;
+    var typeStr: any /** TODO #9100 */;
     switch (type.name) {
       case o.BuiltinTypeName.Bool:
         typeStr = 'boolean';
@@ -251,7 +251,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
   }
 
   getBuiltinMethodName(method: o.BuiltinMethod): string {
-    var name;
+    var name: any /** TODO #9100 */;
     switch (method) {
       case o.BuiltinMethod.ConcatArray:
         name = 'concat';
@@ -270,7 +270,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
 
 
   private _visitParams(params: o.FnParam[], ctx: EmitterVisitorContext): void {
-    this.visitAllObjects((param) => {
+    this.visitAllObjects((param: any /** TODO #9100 */) => {
       ctx.print(param.name);
       ctx.print(':');
       this.visitType(param.type, ctx);
@@ -293,7 +293,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
     ctx.print(value.name);
     if (isPresent(typeParams) && typeParams.length > 0) {
       ctx.print(`<`);
-      this.visitAllObjects((type) => type.visitType(this, ctx), typeParams, ctx, ',');
+      this.visitAllObjects((type: any /** TODO #9100 */) => type.visitType(this, ctx), typeParams, ctx, ',');
       ctx.print(`>`);
     }
   }
diff --git a/modules/@angular/compiler/src/provider_parser.ts b/modules/@angular/compiler/src/provider_parser.ts
index 06b4bdafb8..c5b070b303 100644
--- a/modules/@angular/compiler/src/provider_parser.ts
+++ b/modules/@angular/compiler/src/provider_parser.ts
@@ -162,7 +162,7 @@ export class ProviderElementContext {
     var transformedProviders = resolvedProvider.providers.map((provider) => {
       var transformedUseValue = provider.useValue;
       var transformedUseExisting = provider.useExisting;
-      var transformedDeps;
+      var transformedDeps: any /** TODO #9100 */;
       if (isPresent(provider.useExisting)) {
         var existingDiDep = this._getDependency(
             resolvedProvider.providerType,
diff --git a/modules/@angular/compiler/src/runtime_compiler.ts b/modules/@angular/compiler/src/runtime_compiler.ts
index 8325878b13..52b8d0c5f7 100644
--- a/modules/@angular/compiler/src/runtime_compiler.ts
+++ b/modules/@angular/compiler/src/runtime_compiler.ts
@@ -101,7 +101,7 @@ export class RuntimeCompiler implements ComponentResolver {
                     this._templateParser.parse(compMeta, compMeta.template.template,
                                                normalizedViewDirMetas, pipes, compMeta.type.name);
 
-                var childPromises = [];
+                var childPromises: any[] /** TODO #9100 */ = [];
                 compiledTemplate.init(this._compileComponent(compMeta, parsedTemplate, styles,
                                                              pipes, compilingComponentsPath, childPromises));
                 return PromiseWrapper.all(childPromises).then((_) => { return compiledTemplate; });
@@ -140,7 +140,7 @@ export class RuntimeCompiler implements ComponentResolver {
         childPromises.push(this._compiledTemplateDone.get(childCacheKey));
       }
     });
-    var factory;
+    var factory: any /** TODO #9100 */;
     if (IS_DART || !this._genConfig.useJit) {
       factory = interpretStatements(compileResult.statements, compileResult.viewFactoryVar,
                                     new InterpretiveAppViewInstanceFactory());
@@ -161,7 +161,7 @@ export class RuntimeCompiler implements ComponentResolver {
     var promises = result.dependencies.map((dep) => this._loadStylesheetDep(dep));
     return PromiseWrapper.all(promises)
         .then((cssTexts) => {
-          var nestedCompileResultPromises = [];
+          var nestedCompileResultPromises: any[] /** TODO #9100 */ = [];
           for (var i = 0; i < result.dependencies.length; i++) {
             var dep = result.dependencies[i];
             var cssText = cssTexts[i];
@@ -202,7 +202,7 @@ class CompiledTemplate {
   viewFactory: Function = null;
   proxyViewFactory: Function;
   constructor() {
-    this.proxyViewFactory = (viewUtils, childInjector, contextEl) =>
+    this.proxyViewFactory = (viewUtils: any /** TODO #9100 */, childInjector: any /** TODO #9100 */, contextEl: any /** TODO #9100 */) =>
         this.viewFactory(viewUtils, childInjector, contextEl);
   }
 
diff --git a/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts b/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
index f953d6fafc..396f85f15b 100644
--- a/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
+++ b/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
@@ -238,7 +238,7 @@ export class DomElementSchemaRegistry extends ElementSchemaRegistry {
       typeName.split(',').forEach(tag => this.schema[tag] = type);
       var superType = this.schema[typeParts[1]];
       if (isPresent(superType)) {
-        StringMapWrapper.forEach(superType, (v, k) => type[k] = v);
+        StringMapWrapper.forEach(superType, (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => type[k] = v);
       }
       properties.forEach((property: string) => {
         if (property == '') {
diff --git a/modules/@angular/compiler/src/selector.ts b/modules/@angular/compiler/src/selector.ts
index df2a974339..6d09d55b21 100644
--- a/modules/@angular/compiler/src/selector.ts
+++ b/modules/@angular/compiler/src/selector.ts
@@ -33,7 +33,7 @@ export class CssSelector {
 
   static parse(selector: string): CssSelector[] {
     var results: CssSelector[] = [];
-    var _addResult = (res: CssSelector[], cssSel) => {
+    var _addResult = (res: CssSelector[], cssSel: any /** TODO #9100 */) => {
       if (cssSel.notSelectors.length > 0 && isBlank(cssSel.element) &&
           ListWrapper.isEmpty(cssSel.classNames) && ListWrapper.isEmpty(cssSel.attrs)) {
         cssSel.element = "*";
@@ -42,7 +42,7 @@ export class CssSelector {
     };
     var cssSelector = new CssSelector();
     var matcher = RegExpWrapper.matcher(_SELECTOR_REGEXP, selector);
-    var match;
+    var match: any /** TODO #9100 */;
     var current = cssSelector;
     var inNot = false;
     while (isPresent(match = RegExpMatcherWrapper.next(matcher))) {
@@ -159,7 +159,7 @@ export class SelectorMatcher {
   private _listContexts: SelectorListContext[] = [];
 
   addSelectables(cssSelectors: CssSelector[], callbackCtxt?: any) {
-    var listContext = null;
+    var listContext: any /** TODO #9100 */ = null;
     if (cssSelectors.length > 1) {
       listContext = new SelectorListContext(cssSelectors);
       this._listContexts.push(listContext);
@@ -308,7 +308,7 @@ export class SelectorMatcher {
   }
 
   /** @internal */
-  _matchTerminal(map: Map<string, SelectorContext[]>, name, cssSelector: CssSelector,
+  _matchTerminal(map: Map<string, SelectorContext[]>, name: any /** TODO #9100 */, cssSelector: CssSelector,
                  matchedCallback: (c: CssSelector, a: any) => void): boolean {
     if (isBlank(map) || isBlank(name)) {
       return false;
@@ -322,7 +322,7 @@ export class SelectorMatcher {
     if (isBlank(selectables)) {
       return false;
     }
-    var selectable;
+    var selectable: any /** TODO #9100 */;
     var result = false;
     for (var index = 0; index < selectables.length; index++) {
       selectable = selectables[index];
@@ -332,8 +332,8 @@ export class SelectorMatcher {
   }
 
   /** @internal */
-  _matchPartial(map: Map<string, SelectorMatcher>, name, cssSelector: CssSelector,
-                matchedCallback /*: (c: CssSelector, a: any) => void*/): boolean {
+  _matchPartial(map: Map<string, SelectorMatcher>, name: any /** TODO #9100 */, cssSelector: CssSelector,
+                matchedCallback: any /** TODO #9100 */ /*: (c: CssSelector, a: any) => void*/): boolean {
     if (isBlank(map) || isBlank(name)) {
       return false;
     }
diff --git a/modules/@angular/compiler/src/shadow_css.ts b/modules/@angular/compiler/src/shadow_css.ts
index e93a10b05d..8efbcde79f 100644
--- a/modules/@angular/compiler/src/shadow_css.ts
+++ b/modules/@angular/compiler/src/shadow_css.ts
@@ -175,7 +175,7 @@ export class ShadowCss {
   private _insertPolyfillDirectivesInCssText(cssText: string): string {
     // Difference with webcomponents.js: does not handle comments
     return StringWrapper.replaceAllMapped(cssText, _cssContentNextSelectorRe,
-                                          function(m) { return m[1] + '{'; });
+                                          function(m: any /** TODO #9100 */) { return m[1] + '{'; });
   }
 
   /*
@@ -195,7 +195,7 @@ export class ShadowCss {
   **/
   private _insertPolyfillRulesInCssText(cssText: string): string {
     // Difference with webcomponents.js: does not handle comments
-    return StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m) {
+    return StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m: any /** TODO #9100 */) {
       var rule = m[0];
       rule = StringWrapper.replace(rule, m[1], '');
       rule = StringWrapper.replace(rule, m[2], '');
@@ -241,7 +241,7 @@ export class ShadowCss {
   **/
   private _extractUnscopedRulesFromCssText(cssText: string): string {
     // Difference with webcomponents.js: does not handle comments
-    var r = '', m;
+    var r = '', m: any /** TODO #9100 */;
     var matcher = RegExpWrapper.matcher(_cssContentUnscopedRuleRe, cssText);
     while (isPresent(m = RegExpMatcherWrapper.next(matcher))) {
       var rule = m[0];
@@ -285,9 +285,9 @@ export class ShadowCss {
 
   private _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
     // p1 = :host, p2 = contents of (), p3 rest of rule
-    return StringWrapper.replaceAllMapped(cssText, regExp, function(m) {
+    return StringWrapper.replaceAllMapped(cssText, regExp, function(m: any /** TODO #9100 */) {
       if (isPresent(m[2])) {
-        var parts = m[2].split(','), r = [];
+        var parts = m[2].split(','), r: any[] /** TODO #9100 */ = [];
         for (var i = 0; i < parts.length; i++) {
           var p = parts[i];
           if (isBlank(p)) break;
@@ -341,7 +341,7 @@ export class ShadowCss {
 
   private _scopeSelector(selector: string, scopeSelector: string, hostSelector: string,
                          strict: boolean): string {
-    var r = [], parts = selector.split(',');
+    var r: any[] /** TODO #9100 */ = [], parts = selector.split(',');
     for (var i = 0; i < parts.length; i++) {
       var p = parts[i].trim();
       var deepParts = StringWrapper.split(p, _shadowDeepSelectors);
@@ -392,7 +392,7 @@ export class ShadowCss {
   // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]  /** @internal */
   private _applyStrictSelectorScope(selector: string, scopeSelector: string): string {
     var isRe = /\[is=([^\]]*)\]/g;
-    scopeSelector = StringWrapper.replaceAllMapped(scopeSelector, isRe, (m) => m[1]);
+    scopeSelector = StringWrapper.replaceAllMapped(scopeSelector, isRe, (m: any /** TODO #9100 */) => m[1]);
     var splits = [' ', '>', '+', '~'], scoped = selector, attrName = '[' + scopeSelector + ']';
     for (var i = 0; i < splits.length; i++) {
       var sep = splits[i];
@@ -454,7 +454,7 @@ var _colonHostContextRe = /:host-context/gim;
 var _commentRe = /\/\*[\s\S]*?\*\//g;
 
 function stripComments(input:string):string {
-  return StringWrapper.replaceAllMapped(input, _commentRe, (_) => '');
+  return StringWrapper.replaceAllMapped(input, _commentRe, (_: any /** TODO #9100 */) => '');
 }
 
 var _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
@@ -470,7 +470,7 @@ export class CssRule {
 export function processRules(input:string, ruleCallback:Function):string {
   var inputWithEscapedBlocks = escapeBlocks(input);
   var nextBlockIndex = 0;
-  return StringWrapper.replaceAllMapped(inputWithEscapedBlocks.escapedString, _ruleRe, function(m) {
+  return StringWrapper.replaceAllMapped(inputWithEscapedBlocks.escapedString, _ruleRe, function(m: any /** TODO #9100 */) {
     var selector = m[2];
     var content = '';
     var suffix = m[4];
@@ -491,10 +491,10 @@ class StringWithEscapedBlocks {
 
 function escapeBlocks(input:string):StringWithEscapedBlocks {
   var inputParts = StringWrapper.split(input, _curlyRe);
-  var resultParts = [];
-  var escapedBlocks = [];
+  var resultParts: any[] /** TODO #9100 */ = [];
+  var escapedBlocks: any[] /** TODO #9100 */ = [];
   var bracketCount = 0;
-  var currentBlockParts = [];
+  var currentBlockParts: any[] /** TODO #9100 */ = [];
   for (var partIndex = 0; partIndex<inputParts.length; partIndex++) {
     var part = inputParts[partIndex];
     if (part == CLOSE_CURLY) {
diff --git a/modules/@angular/compiler/src/style_compiler.ts b/modules/@angular/compiler/src/style_compiler.ts
index 36bb9a6459..3ff469b600 100644
--- a/modules/@angular/compiler/src/style_compiler.ts
+++ b/modules/@angular/compiler/src/style_compiler.ts
@@ -43,7 +43,7 @@ export class StyleCompiler {
                          shim: boolean): StylesCompileResult {
     var styleExpressions =
         plainStyles.map(plainStyle => o.literal(this._shimIfNeeded(plainStyle, shim)));
-    var dependencies = [];
+    var dependencies: any[] /** TODO #9100 */ = [];
     for (var i = 0; i < absUrls.length; i++) {
       var identifier = new CompileIdentifierMetadata({name: getStylesVarName(null)});
       dependencies.push(new StylesCompileDependency(absUrls[i], shim, identifier));
diff --git a/modules/@angular/compiler/src/style_url_resolver.ts b/modules/@angular/compiler/src/style_url_resolver.ts
index 42fbce57c8..b323237451 100644
--- a/modules/@angular/compiler/src/style_url_resolver.ts
+++ b/modules/@angular/compiler/src/style_url_resolver.ts
@@ -20,8 +20,8 @@ export function isStyleUrlResolvable(url: string): boolean {
  */
 export function extractStyleUrls(resolver: UrlResolver, baseUrl: string,
                                  cssText: string): StyleWithImports {
-  var foundUrls = [];
-  var modifiedCssText = StringWrapper.replaceAllMapped(cssText, _cssImportRe, (m) => {
+  var foundUrls: any[] /** TODO #9100 */ = [];
+  var modifiedCssText = StringWrapper.replaceAllMapped(cssText, _cssImportRe, (m: any /** TODO #9100 */) => {
     var url = isPresent(m[1]) ? m[1] : m[2];
     if (!isStyleUrlResolvable(url)) {
       // Do not attempt to resolve non-package absolute URLs with URI scheme
diff --git a/modules/@angular/compiler/src/template_ast.ts b/modules/@angular/compiler/src/template_ast.ts
index d4e5e20a82..f30ee82b18 100644
--- a/modules/@angular/compiler/src/template_ast.ts
+++ b/modules/@angular/compiler/src/template_ast.ts
@@ -244,7 +244,7 @@ export interface TemplateAstVisitor {
  */
 export function templateVisitAll(visitor: TemplateAstVisitor, asts: TemplateAst[],
                                  context: any = null): any[] {
-  var result = [];
+  var result: any[] /** TODO #9100 */ = [];
   asts.forEach(ast => {
     var astResult = ast.visit(visitor, context);
     if (isPresent(astResult)) {
diff --git a/modules/@angular/compiler/src/template_parser.ts b/modules/@angular/compiler/src/template_parser.ts
index e02dab4f78..46b68aefa6 100644
--- a/modules/@angular/compiler/src/template_parser.ts
+++ b/modules/@angular/compiler/src/template_parser.ts
@@ -141,7 +141,7 @@ export class TemplateParser {
            templateUrl: string): TemplateParseResult {
     var htmlAstWithErrors = this._htmlParser.parse(template, templateUrl);
     var errors:ParseError[] = htmlAstWithErrors.errors;
-    var result;
+    var result: any /** TODO #???? */;
     if (htmlAstWithErrors.rootNodes.length > 0) {
       var uniqDirectives = <CompileDirectiveMetadata[]>removeDuplicates(directives);
       var uniqPipes = <CompilePipeMetadata[]>removeDuplicates(pipes);
@@ -170,10 +170,10 @@ export class TemplateParser {
 
   /** @internal */
   _assertNoReferenceDuplicationOnTemplate(result:any[], errors:TemplateParseError[]):void {
-    const existingReferences = [];
+    const existingReferences: any[] /** TODO #???? */ = [];
     result
       .filter(element => !!element.references)
-      .forEach(element => element.references.forEach(reference=> {
+      .forEach(element => element.references.forEach((reference: any /** TODO #???? */)=> {
         const name = reference.name;
         if (existingReferences.indexOf(name) < 0) {
           existingReferences.push(name);
@@ -335,7 +335,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
     var templateElementVars: VariableAst[] = [];
 
     var hasInlineTemplates = false;
-    var attrs = [];
+    var attrs: any[] /** TODO #???? */ = [];
     var lcElName = splitNsName(nodeName.toLowerCase())[1];
     var isTemplateElement = lcElName == TEMPLATE_ELEMENT;
 
@@ -377,7 +377,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
                                  CssSelector.parse(preparsedElement.projectAs)[0] :
                                  elementCssSelector;
     var ngContentIndex = parent.findNgContentIndex(projectionSelector);
-    var parsedElement;
+    var parsedElement: any /** TODO #???? */;
 
     if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
       if (isPresent(element.children) && element.children.length > 0) {
@@ -434,7 +434,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
   private _parseInlineTemplateBinding(attr: HtmlAttrAst, targetMatchableAttrs: string[][],
                                       targetProps: BoundElementOrDirectiveProperty[],
                                       targetVars: VariableAst[]): boolean {
-    var templateBindingsSource = null;
+    var templateBindingsSource: any /** TODO #???? */ = null;
     if (attr.name == TEMPLATE_ATTR) {
       templateBindingsSource = attr.value;
     } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
@@ -667,7 +667,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
                             elOrDirRef.sourceSpan);
         };
       } else if (isBlank(component)) {
-        var refToken = null;
+        var refToken: any /** TODO #???? */ = null;
         if (isTemplateElement) {
           refToken = identifierToken(Identifiers.TemplateRef);
         }
@@ -744,8 +744,8 @@ class TemplateParseVisitor implements HtmlAstVisitor {
 
   private _createElementPropertyAst(elementName: string, name: string, ast: AST,
                                     sourceSpan: ParseSourceSpan): BoundElementPropertyAst {
-    var unit = null;
-    var bindingType;
+    var unit: any /** TODO #???? */ = null;
+    var bindingType: any /** TODO #???? */;
     var boundPropertyName: string;
     var parts = name.split(PROPERTY_PARTS_SEPARATOR);
     let securityContext: SecurityContext;
@@ -837,7 +837,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
     var allDirectiveEvents = new Set<string>();
     directives.forEach(directive => {
       StringMapWrapper.forEach(directive.directive.outputs,
-                               (eventName: string, _) => { allDirectiveEvents.add(eventName); });
+                               (eventName: string, _: any /** TODO #???? */) => { allDirectiveEvents.add(eventName); });
     });
     events.forEach(event => {
       if (isPresent(event.target) || !SetWrapper.has(allDirectiveEvents, event.name)) {
@@ -897,7 +897,7 @@ class ElementContext {
   static create(isTemplateElement: boolean, directives: DirectiveAst[],
                 providerContext: ProviderElementContext): ElementContext {
     var matcher = new SelectorMatcher();
-    var wildcardNgContentIndex = null;
+    var wildcardNgContentIndex: any /** TODO #???? */ = null;
     var component = directives.find(directive => directive.directive.isComponent);
     if (isPresent(component)) {
       var ngContentSelectors = component.directive.template.ngContentSelectors;
@@ -917,7 +917,7 @@ class ElementContext {
               public providerContext: ProviderElementContext) {}
 
   findNgContentIndex(selector: CssSelector): number {
-    var ngContentIndices = [];
+    var ngContentIndices: any[] /** TODO #???? */ = [];
     this._ngContentIndexMatcher.match(
         selector, (selector, ngContentIndex) => { ngContentIndices.push(ngContentIndex); });
     ListWrapper.sort(ngContentIndices);
@@ -963,7 +963,7 @@ export class PipeCollector extends RecursiveAstVisitor {
 }
 
 function removeDuplicates(items: CompileMetadataWithType[]): CompileMetadataWithType[] {
-  let res = [];
+  let res: any[] /** TODO #???? */ = [];
   items.forEach(item => {
     let hasMatch =
         res.filter(r => r.type.name == item.type.name && r.type.moduleUrl == item.type.moduleUrl &&
diff --git a/modules/@angular/compiler/src/template_preparser.ts b/modules/@angular/compiler/src/template_preparser.ts
index 4ecc74d8f2..01edb14021 100644
--- a/modules/@angular/compiler/src/template_preparser.ts
+++ b/modules/@angular/compiler/src/template_preparser.ts
@@ -15,9 +15,9 @@ const NG_NON_BINDABLE_ATTR = 'ngNonBindable';
 const NG_PROJECT_AS = 'ngProjectAs';
 
 export function preparseElement(ast: HtmlElementAst): PreparsedElement {
-  var selectAttr = null;
-  var hrefAttr = null;
-  var relAttr = null;
+  var selectAttr: any /** TODO #9100 */ = null;
+  var hrefAttr: any /** TODO #9100 */ = null;
+  var relAttr: any /** TODO #9100 */ = null;
   var nonBindable = false;
   var projectAs: string = null;
   ast.attrs.forEach(attr => {
diff --git a/modules/@angular/compiler/src/url_resolver.ts b/modules/@angular/compiler/src/url_resolver.ts
index ee15f46cf9..f1e87d8248 100644
--- a/modules/@angular/compiler/src/url_resolver.ts
+++ b/modules/@angular/compiler/src/url_resolver.ts
@@ -105,7 +105,7 @@ export function getUrlScheme(url: string): string {
 function _buildFromEncodedParts(opt_scheme?: string, opt_userInfo?: string, opt_domain?: string,
                                 opt_port?: string, opt_path?: string, opt_queryData?: string,
                                 opt_fragment?: string): string {
-  var out = [];
+  var out: any[] /** TODO #9100 */ = [];
 
   if (isPresent(opt_scheme)) {
     out.push(opt_scheme + ':');
diff --git a/modules/@angular/compiler/src/util.ts b/modules/@angular/compiler/src/util.ts
index d53ba6d07f..73340a60e7 100644
--- a/modules/@angular/compiler/src/util.ts
+++ b/modules/@angular/compiler/src/util.ts
@@ -16,12 +16,12 @@ var DASH_CASE_REGEXP = /-([a-z])/g;
 
 export function camelCaseToDashCase(input: string): string {
   return StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP,
-                                        (m) => { return '-' + m[1].toLowerCase(); });
+                                        (m: any /** TODO #9100 */) => { return '-' + m[1].toLowerCase(); });
 }
 
 export function dashCaseToCamelCase(input: string): string {
   return StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP,
-                                        (m) => { return m[1].toUpperCase(); });
+                                        (m: any /** TODO #9100 */) => { return m[1].toUpperCase(); });
 }
 
 export function splitAtColon(input: string, defaultValues: string[]): string[] {
@@ -63,7 +63,7 @@ export class ValueTransformer implements ValueVisitor {
   visitStringMap(map: {[key: string]: any}, context: any): any {
     var result = {};
     StringMapWrapper.forEach(map,
-                             (value, key) => { result[key] = visitValue(value, this, context); });
+                             (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => { (result as any /** TODO #9100 */)[key] = visitValue(value, this, context); });
     return result;
   }
   visitPrimitive(value: any, context: any): any { return value; }
diff --git a/modules/@angular/compiler/src/view_compiler/compile_element.ts b/modules/@angular/compiler/src/view_compiler/compile_element.ts
index 79f48dc2b4..af755bb718 100644
--- a/modules/@angular/compiler/src/view_compiler/compile_element.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_element.ts
@@ -167,9 +167,9 @@ export class CompileElement extends CompileNode {
           queriesWithReads,
           queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
     });
-    StringMapWrapper.forEach(this.referenceTokens, (_, varName) => {
+    StringMapWrapper.forEach(this.referenceTokens, (_: any /** TODO #9100 */, varName: any /** TODO #9100 */) => {
       var token = this.referenceTokens[varName];
-      var varValue;
+      var varValue: any /** TODO #9100 */;
       if (isPresent(token)) {
         varValue = this._instances.get(token);
       } else {
@@ -282,7 +282,7 @@ export class CompileElement extends CompileNode {
 
   private _getLocalDependency(requestingProviderType: ProviderAstType,
                               dep: CompileDiDependencyMetadata): o.Expression {
-    var result = null;
+    var result: any /** TODO #9100 */ = null;
     // constructor content query
     if (isBlank(result) && isPresent(dep.query)) {
       result = this._addQuery(dep.query, null).queryList;
@@ -319,7 +319,7 @@ export class CompileElement extends CompileNode {
   private _getDependency(requestingProviderType: ProviderAstType,
                          dep: CompileDiDependencyMetadata): o.Expression {
     var currElement: CompileElement = this;
-    var result = null;
+    var result: any /** TODO #9100 */ = null;
     if (dep.isValue) {
       result = o.literal(dep.value);
     }
@@ -346,7 +346,7 @@ export class CompileElement extends CompileNode {
 function createInjectInternalCondition(nodeIndex: number, childNodeCount: number,
                                        provider: ProviderAst,
                                        providerExpr: o.Expression): o.Statement {
-  var indexCondition;
+  var indexCondition: any /** TODO #9100 */;
   if (childNodeCount > 0) {
     indexCondition = o.literal(nodeIndex)
                          .lowerEquals(InjectMethodVars.requestNodeIndex)
@@ -364,8 +364,8 @@ function createProviderProperty(propName: string, provider: ProviderAst,
                                 providerValueExpressions: o.Expression[], isMulti: boolean,
                                 isEager: boolean, compileElement: CompileElement): o.Expression {
   var view = compileElement.view;
-  var resolvedProviderValueExpr;
-  var type;
+  var resolvedProviderValueExpr: any /** TODO #9100 */;
+  var type: any /** TODO #9100 */;
   if (isMulti) {
     resolvedProviderValueExpr = o.literalArr(providerValueExpressions);
     type = new o.ArrayType(o.DYNAMIC_TYPE);
@@ -410,9 +410,9 @@ class _ValueOutputAstTransformer extends ValueTransformer {
     return o.literalArr(arr.map(value => visitValue(value, this, context)));
   }
   visitStringMap(map: {[key: string]: any}, context: any): o.Expression {
-    var entries = [];
+    var entries: any[] /** TODO #9100 */ = [];
     StringMapWrapper.forEach(
-        map, (value, key) => { entries.push([key, visitValue(value, this, context)]); });
+        map, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => { entries.push([key, visitValue(value, this, context)]); });
     return o.literalMap(entries);
   }
   visitPrimitive(value: any, context: any): o.Expression { return o.literal(value); }
diff --git a/modules/@angular/compiler/src/view_compiler/compile_query.ts b/modules/@angular/compiler/src/view_compiler/compile_query.ts
index b55b61a371..68a7978d18 100644
--- a/modules/@angular/compiler/src/view_compiler/compile_query.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_query.ts
@@ -57,7 +57,7 @@ export class CompileQuery {
     return !this._values.values.some(value => value instanceof ViewQueryValues);
   }
 
-  afterChildren(targetStaticMethod, targetDynamicMethod: CompileMethod) {
+  afterChildren(targetStaticMethod: any /** TODO #9100 */, targetDynamicMethod: CompileMethod) {
     var values = createQueryValues(this._values);
     var updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
     if (isPresent(this.ownerDirectiveExpression)) {
diff --git a/modules/@angular/compiler/src/view_compiler/event_binder.ts b/modules/@angular/compiler/src/view_compiler/event_binder.ts
index b1791d46e6..6ec630c6f3 100644
--- a/modules/@angular/compiler/src/view_compiler/event_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/event_binder.ts
@@ -84,7 +84,7 @@ export class CompileEventListener {
   }
 
   listenToRenderer() {
-    var listenExpr;
+    var listenExpr: any /** TODO #9100 */;
     var eventListener = o.THIS_EXPR.callMethod(
         'eventHandler',
         [o.THIS_EXPR.prop(this._methodName).callMethod(o.BuiltinMethod.bind, [o.THIS_EXPR])]);
@@ -139,7 +139,7 @@ export function collectEventListeners(hostEvents: BoundEventAst[], dirs: Directi
 
 export function bindDirectiveOutputs(directiveAst: DirectiveAst, directiveInstance: o.Expression,
                                      eventListeners: CompileEventListener[]) {
-  StringMapWrapper.forEach(directiveAst.directive.outputs, (eventName, observablePropName) => {
+  StringMapWrapper.forEach(directiveAst.directive.outputs, (eventName: any /** TODO #9100 */, observablePropName: any /** TODO #9100 */) => {
     eventListeners.filter(listener => listener.eventName == eventName)
         .forEach(
             (listener) => { listener.listenToDirective(directiveInstance, observablePropName); });
diff --git a/modules/@angular/compiler/src/view_compiler/expression_converter.ts b/modules/@angular/compiler/src/view_compiler/expression_converter.ts
index e310fea022..adb2a31120 100644
--- a/modules/@angular/compiler/src/view_compiler/expression_converter.ts
+++ b/modules/@angular/compiler/src/view_compiler/expression_converter.ts
@@ -29,7 +29,7 @@ export function convertCdExpressionToIr(
 export function convertCdStatementToIr(nameResolver: NameResolver, implicitReceiver: o.Expression,
                                        stmt: cdAst.AST): o.Statement[] {
   var visitor = new _AstToIrVisitor(nameResolver, implicitReceiver, null);
-  var statements = [];
+  var statements: any[] /** TODO #9100 */ = [];
   flattenStatements(stmt.visit(visitor, _Mode.Statement), statements);
   return statements;
 }
@@ -66,7 +66,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
               private _valueUnwrapper: o.ReadVarExpr) {}
 
   visitBinary(ast: cdAst.Binary, mode: _Mode): any {
-    var op;
+    var op: any /** TODO #9100 */;
     switch (ast.operation) {
       case '+':
         op = o.BinaryOperator.Plus;
@@ -171,7 +171,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
         mode, this._nameResolver.createLiteralArray(this.visitAll(ast.expressions, mode)));
   }
   visitLiteralMap(ast: cdAst.LiteralMap, mode: _Mode): any {
-    var parts = [];
+    var parts: any[] /** TODO #9100 */ = [];
     for (var i = 0; i < ast.keys.length; i++) {
       parts.push([ast.keys[i], ast.values[i].visit(this, _Mode.Expression)]);
     }
@@ -182,7 +182,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
   }
   visitMethodCall(ast: cdAst.MethodCall, mode: _Mode): any {
     var args = this.visitAll(ast.args, _Mode.Expression);
-    var result = null;
+    var result: any /** TODO #9100 */ = null;
     var receiver = ast.receiver.visit(this, _Mode.Expression);
     if (receiver === IMPLICIT_RECEIVER) {
       var varExpr = this._nameResolver.getLocal(ast.name);
@@ -201,7 +201,7 @@ class _AstToIrVisitor implements cdAst.AstVisitor {
     return convertToStatementIfNeeded(mode, o.not(ast.expression.visit(this, _Mode.Expression)));
   }
   visitPropertyRead(ast: cdAst.PropertyRead, mode: _Mode): any {
-    var result = null;
+    var result: any /** TODO #9100 */ = null;
     var receiver = ast.receiver.visit(this, _Mode.Expression);
     if (receiver === IMPLICIT_RECEIVER) {
       result = this._nameResolver.getLocal(ast.name);
diff --git a/modules/@angular/compiler/src/view_compiler/property_binder.ts b/modules/@angular/compiler/src/view_compiler/property_binder.ts
index c3b0dd06fd..45fea0a63a 100644
--- a/modules/@angular/compiler/src/view_compiler/property_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/property_binder.ts
@@ -97,7 +97,7 @@ function bindAndWriteToRenderer(boundProps: BoundElementPropertyAst[], context:
     var renderMethod: string;
     var oldRenderValue: o.Expression = sanitizedValue(boundProp, fieldExpr);
     var renderValue: o.Expression = sanitizedValue(boundProp, currValExpr);
-    var updateStmts = [];
+    var updateStmts: any[] /** TODO #9100 */ = [];
     switch (boundProp.type) {
       case PropertyBindingType.Property:
         if (view.genConfig.logBindingUpdate) {
diff --git a/modules/@angular/compiler/src/view_compiler/util.ts b/modules/@angular/compiler/src/view_compiler/util.ts
index 4f0834a776..4d3b41de07 100644
--- a/modules/@angular/compiler/src/view_compiler/util.ts
+++ b/modules/@angular/compiler/src/view_compiler/util.ts
@@ -63,7 +63,7 @@ export function createDiTokenExpression(token: CompileTokenMetadata): o.Expressi
 }
 
 export function createFlatArray(expressions: o.Expression[]): o.Expression {
-  var lastNonArrayExpressions = [];
+  var lastNonArrayExpressions: any[] /** TODO #9100 */ = [];
   var result: o.Expression = o.literalArr([]);
   for (var i = 0; i < expressions.length; i++) {
     var expr = expressions[i];
diff --git a/modules/@angular/compiler/src/view_compiler/view_builder.ts b/modules/@angular/compiler/src/view_compiler/view_builder.ts
index 2cf024c72a..9059f66b80 100644
--- a/modules/@angular/compiler/src/view_compiler/view_builder.ts
+++ b/modules/@angular/compiler/src/view_compiler/view_builder.ts
@@ -179,7 +179,7 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
 
   visitElement(ast: ElementAst, parent: CompileElement): any {
     var nodeIndex = this.view.nodes.length;
-    var createRenderNodeExpr;
+    var createRenderNodeExpr: any /** TODO #9100 */;
     var debugContextExpr = this.view.createMethod.resetDebugInfoExpr(nodeIndex, ast);
     if (nodeIndex === 0 && this.view.viewType === ViewType.HOST) {
       createRenderNodeExpr = o.THIS_EXPR.callMethod(
@@ -234,7 +234,7 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
     compileElement.afterChildren(this.view.nodes.length - nodeIndex - 1);
 
     if (isPresent(compViewExpr)) {
-      var codeGenContentNodes;
+      var codeGenContentNodes: any /** TODO #9100 */;
       if (this.view.component.type.isHost) {
         codeGenContentNodes = ViewProperties.projectableNodes;
       } else {
@@ -304,9 +304,9 @@ class ViewBuilderVisitor implements TemplateAstVisitor {
 function _mergeHtmlAndDirectiveAttrs(declaredHtmlAttrs: {[key: string]: string},
                                      directives: CompileDirectiveMetadata[]): string[][] {
   var result: {[key: string]: string} = {};
-  StringMapWrapper.forEach(declaredHtmlAttrs, (value, key) => { result[key] = value; });
+  StringMapWrapper.forEach(declaredHtmlAttrs, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => { result[key] = value; });
   directives.forEach(directiveMeta => {
-    StringMapWrapper.forEach(directiveMeta.hostAttributes, (value, name) => {
+    StringMapWrapper.forEach(directiveMeta.hostAttributes, (value: any /** TODO #9100 */, name: any /** TODO #9100 */) => {
       var prevValue = result[name];
       result[name] = isPresent(prevValue) ? mergeAttributeValue(name, prevValue, value) : value;
     });
@@ -329,12 +329,12 @@ function mergeAttributeValue(attrName: string, attrValue1: string, attrValue2: s
 }
 
 function mapToKeyValueArray(data: {[key: string]: string}): string[][] {
-  var entryArray = [];
-  StringMapWrapper.forEach(data, (value, name) => { entryArray.push([name, value]); });
+  var entryArray: any[] /** TODO #9100 */ = [];
+  StringMapWrapper.forEach(data, (value: any /** TODO #9100 */, name: any /** TODO #9100 */) => { entryArray.push([name, value]); });
   // We need to sort to get a defined output order
   // for tests and for caching generated artifacts...
   ListWrapper.sort(entryArray, (entry1, entry2) => StringWrapper.compare(entry1[0], entry2[0]));
-  var keyValueArray = [];
+  var keyValueArray: any[] /** TODO #9100 */ = [];
   entryArray.forEach((entry) => { keyValueArray.push([entry[0], entry[1]]); });
   return keyValueArray;
 }
@@ -369,13 +369,13 @@ function createStaticNodeDebugInfo(node: CompileNode): o.Expression {
   var compileElement = node instanceof CompileElement ? node : null;
   var providerTokens: o.Expression[] = [];
   var componentToken: o.Expression = o.NULL_EXPR;
-  var varTokenEntries = [];
+  var varTokenEntries: any[] /** TODO #9100 */ = [];
   if (isPresent(compileElement)) {
     providerTokens = compileElement.getProviderTokens();
     if (isPresent(compileElement.component)) {
       componentToken = createDiTokenExpression(identifierToken(compileElement.component.type));
     }
-    StringMapWrapper.forEach(compileElement.referenceTokens, (token, varName) => {
+    StringMapWrapper.forEach(compileElement.referenceTokens, (token: any /** TODO #9100 */, varName: any /** TODO #9100 */) => {
       varTokenEntries.push(
           [varName, isPresent(token) ? createDiTokenExpression(token) : o.NULL_EXPR]);
     });
@@ -446,8 +446,8 @@ function createViewFactory(view: CompileView, viewClass: o.ClassStmt,
     new o.FnParam(ViewConstructorVars.parentInjector.name, o.importType(Identifiers.Injector)),
     new o.FnParam(ViewConstructorVars.declarationEl.name, o.importType(Identifiers.AppElement))
   ];
-  var initRenderCompTypeStmts = [];
-  var templateUrlInfo;
+  var initRenderCompTypeStmts: any[] /** TODO #9100 */ = [];
+  var templateUrlInfo: any /** TODO #9100 */;
   if (view.component.template.templateUrl == view.component.type.moduleUrl) {
     templateUrlInfo =
         `${view.component.type.moduleUrl} class ${view.component.type.name} - inline template`;
@@ -483,7 +483,7 @@ function createViewFactory(view: CompileView, viewClass: o.ClassStmt,
 
 function generateCreateMethod(view: CompileView): o.Statement[] {
   var parentRenderNodeExpr: o.Expression = o.NULL_EXPR;
-  var parentRenderNodeStmts = [];
+  var parentRenderNodeStmts: any[] /** TODO #9100 */ = [];
   if (view.viewType === ViewType.COMPONENT) {
     parentRenderNodeExpr = ViewProperties.renderer.callMethod(
         'createViewRoot', [o.THIS_EXPR.prop('declarationAppElement').prop('nativeElement')]);
@@ -513,7 +513,7 @@ function generateCreateMethod(view: CompileView): o.Statement[] {
 }
 
 function generateDetectChangesMethod(view: CompileView): o.Statement[] {
-  var stmts = [];
+  var stmts: any[] /** TODO #9100 */ = [];
   if (view.detectChangesInInputsMethod.isEmpty() && view.updateContentQueriesMethod.isEmpty() &&
       view.afterContentLifecycleCallbacksMethod.isEmpty() &&
       view.detectChangesRenderPropertiesMethod.isEmpty() &&
@@ -538,7 +538,7 @@ function generateDetectChangesMethod(view: CompileView): o.Statement[] {
     stmts.push(new o.IfStmt(o.not(DetectChangesVars.throwOnChange), afterViewStmts));
   }
 
-  var varStmts = [];
+  var varStmts: any[] /** TODO #9100 */ = [];
   var readVars = o.findReadVarNames(stmts);
   if (SetWrapper.has(readVars, DetectChangesVars.changed.name)) {
     varStmts.push(DetectChangesVars.changed.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE));
diff --git a/modules/@angular/compiler/src/view_compiler/view_compiler.ts b/modules/@angular/compiler/src/view_compiler/view_compiler.ts
index c00da58ce0..070031ab81 100644
--- a/modules/@angular/compiler/src/view_compiler/view_compiler.ts
+++ b/modules/@angular/compiler/src/view_compiler/view_compiler.ts
@@ -22,9 +22,9 @@ export class ViewCompiler {
 
   compileComponent(component: CompileDirectiveMetadata, template: TemplateAst[],
                    styles: o.Expression, pipes: CompilePipeMetadata[]): ViewCompileResult {
-    var dependencies = [];
+    var dependencies: any[] /** TODO #9100 */ = [];
     var compiledAnimations = this._animationCompiler.compileComponent(component);
-    var statements = [];
+    var statements: any[] /** TODO #9100 */ = [];
     compiledAnimations.map(entry => {
       statements.push(entry.statesMapStatement);
       statements.push(entry.fnStatement);
diff --git a/modules/@angular/compiler/test/animation/animation_compiler_spec.ts b/modules/@angular/compiler/test/animation/animation_compiler_spec.ts
index b688276c6b..f5c1293e9e 100644
--- a/modules/@angular/compiler/test/animation/animation_compiler_spec.ts
+++ b/modules/@angular/compiler/test/animation/animation_compiler_spec.ts
@@ -25,7 +25,7 @@ import {CompileMetadataResolver} from '../../src/metadata_resolver';
 
 export function main() {
   describe('RuntimeAnimationCompiler', () => {
-    var resolver;
+    var resolver: any /** TODO #9100 */;
     beforeEach(inject([CompileMetadataResolver], (res: CompileMetadataResolver) => {
       resolver = res;
     }));
diff --git a/modules/@angular/compiler/test/animation/animation_parser_spec.ts b/modules/@angular/compiler/test/animation/animation_parser_spec.ts
index f44e7a77e0..e8912bbfeb 100644
--- a/modules/@angular/compiler/test/animation/animation_parser_spec.ts
+++ b/modules/@angular/compiler/test/animation/animation_parser_spec.ts
@@ -52,7 +52,7 @@ export function main() {
   describe('parseAnimationEntry', () => {
     var combineStyles = (styles: AnimationStylesAst): {[key: string]: string | number} => {
       var flatStyles: {[key: string]: string | number} = {};
-      styles.styles.forEach(entry => StringMapWrapper.forEach(entry, (val, prop) => { flatStyles[prop] = val; }));
+      styles.styles.forEach(entry => StringMapWrapper.forEach(entry, (val: any /** TODO #9100 */, prop: any /** TODO #9100 */) => { flatStyles[prop] = val; }));
       return flatStyles;
     };
 
@@ -62,7 +62,7 @@ export function main() {
 
     var collectStepStyles = (step: AnimationStepAst): Array<{[key: string]: string | number}> => {
       var keyframes = step.keyframes;
-      var styles = [];
+      var styles: any[] /** TODO #9100 */ = [];
       if (step.startingStyles.styles.length > 0) {
         styles.push(combineStyles(step.startingStyles));
       }
@@ -70,7 +70,7 @@ export function main() {
       return styles;
     };
 
-    var resolver;
+    var resolver: any /** TODO #9100 */;
     beforeEach(inject([CompileMetadataResolver], (res: CompileMetadataResolver) => {
       resolver = res;
     }));
diff --git a/modules/@angular/compiler/test/css/lexer_spec.ts b/modules/@angular/compiler/test/css/lexer_spec.ts
index 86b5df0ea5..fa95427384 100644
--- a/modules/@angular/compiler/test/css/lexer_spec.ts
+++ b/modules/@angular/compiler/test/css/lexer_spec.ts
@@ -20,12 +20,12 @@ import {
 } from '@angular/compiler/src/css/lexer';
 
 export function main() {
-  function tokenize(code, trackComments: boolean = false,
+  function tokenize(code: any /** TODO #9100 */, trackComments: boolean = false,
                     mode: CssLexerMode = CssLexerMode.ALL): CssToken[] {
     var scanner = new CssLexer().scan(code, trackComments);
     scanner.setMode(mode);
 
-    var tokens = [];
+    var tokens: any[] /** TODO #9100 */ = [];
     var output = scanner.scan();
     while (output != null) {
       var error = output.error;
@@ -280,7 +280,7 @@ export function main() {
       it('should throw an error if a selector is being parsed while in the wrong mode', () => {
         var cssCode = ".class > tag";
 
-        var capturedMessage;
+        var capturedMessage: any /** TODO #9100 */;
         try {
           tokenize(cssCode, false, CssLexerMode.STYLE_BLOCK);
         } catch (e) {
@@ -304,7 +304,7 @@ export function main() {
     describe('Attribute Mode', () => {
       it('should consider attribute selectors as valid input and throw when an invalid modifier is used',
          () => {
-           function tokenizeAttr(modifier) {
+           function tokenizeAttr(modifier: any /** TODO #9100 */) {
              var cssCode = "value" + modifier + "='something'";
              return tokenize(cssCode, false, CssLexerMode.ATTRIBUTE_SELECTOR);
            }
@@ -322,7 +322,7 @@ export function main() {
 
     describe('Media Query Mode', () => {
       it('should validate media queries with a reduced subset of valid characters', () => {
-        function tokenizeQuery(code) { return tokenize(code, false, CssLexerMode.MEDIA_QUERY); }
+        function tokenizeQuery(code: any /** TODO #9100 */) { return tokenize(code, false, CssLexerMode.MEDIA_QUERY); }
 
         // the reason why the numbers are so high is because MediaQueries keep
         // track of the whitespace values
@@ -341,7 +341,7 @@ export function main() {
     describe('Pseudo Selector Mode', () => {
       it('should validate pseudo selector identifiers with a reduced subset of valid characters',
          () => {
-           function tokenizePseudo(code) {
+           function tokenizePseudo(code: any /** TODO #9100 */) {
              return tokenize(code, false, CssLexerMode.PSEUDO_SELECTOR);
            }
 
@@ -358,7 +358,7 @@ export function main() {
     describe('Pseudo Selector Mode', () => {
       it('should validate pseudo selector identifiers with a reduced subset of valid characters',
          () => {
-           function tokenizePseudo(code) {
+           function tokenizePseudo(code: any /** TODO #9100 */) {
              return tokenize(code, false, CssLexerMode.PSEUDO_SELECTOR);
            }
 
@@ -374,7 +374,7 @@ export function main() {
 
     describe('Style Block Mode', () => {
       it('should style blocks with a reduced subset of valid characters', () => {
-        function tokenizeStyles(code) { return tokenize(code, false, CssLexerMode.STYLE_BLOCK); }
+        function tokenizeStyles(code: any /** TODO #9100 */) { return tokenize(code, false, CssLexerMode.STYLE_BLOCK); }
 
         expect(tokenizeStyles(`
           key: value;
diff --git a/modules/@angular/compiler/test/css/parser_spec.ts b/modules/@angular/compiler/test/css/parser_spec.ts
index 08240cc8b0..a6aceb279f 100644
--- a/modules/@angular/compiler/test/css/parser_spec.ts
+++ b/modules/@angular/compiler/test/css/parser_spec.ts
@@ -33,7 +33,7 @@ import {
 
 import {CssLexer} from '@angular/compiler/src/css/lexer';
 
-export function assertTokens(tokens, valuesArr) {
+export function assertTokens(tokens: any /** TODO #9100 */, valuesArr: any /** TODO #9100 */) {
   for (var i = 0; i < tokens.length; i++) {
     expect(tokens[i].strValue == valuesArr[i]);
   }
@@ -41,14 +41,14 @@ export function assertTokens(tokens, valuesArr) {
 
 export function main() {
   describe('CssParser', () => {
-    function parse(css): ParsedCssResult {
+    function parse(css: any /** TODO #9100 */): ParsedCssResult {
       var lexer = new CssLexer();
       var scanner = lexer.scan(css);
       var parser = new CssParser(scanner, 'some-fake-file-name.css');
       return parser.parse();
     }
 
-    function makeAST(css): CssStyleSheetAST {
+    function makeAST(css: any /** TODO #9100 */): CssStyleSheetAST {
       var output = parse(css);
       var errors = output.errors;
       if (errors.length > 0) {
diff --git a/modules/@angular/compiler/test/css/visitor_spec.ts b/modules/@angular/compiler/test/css/visitor_spec.ts
index 1719980578..0243c04479 100644
--- a/modules/@angular/compiler/test/css/visitor_spec.ts
+++ b/modules/@angular/compiler/test/css/visitor_spec.ts
@@ -37,7 +37,7 @@ import {
 
 import {CssLexer} from '@angular/compiler/src/css/lexer';
 
-function _assertTokens(tokens, valuesArr) {
+function _assertTokens(tokens: any /** TODO #9100 */, valuesArr: any /** TODO #9100 */) {
   for (var i = 0; i < tokens.length; i++) {
     expect(tokens[i].strValue == valuesArr[i]);
   }
@@ -46,16 +46,16 @@ function _assertTokens(tokens, valuesArr) {
 class MyVisitor implements CssASTVisitor {
   captures: {[key: string]: any[]} = {};
 
-  _capture(method, ast, context) {
+  _capture(method: any /** TODO #9100 */, ast: any /** TODO #9100 */, context: any /** TODO #9100 */) {
     this.captures[method] = isPresent(this.captures[method]) ? this.captures[method] : [];
     this.captures[method].push([ast, context]);
   }
 
   constructor(ast: CssStyleSheetAST, context?: any) { ast.visit(this, context); }
 
-  visitCssValue(ast, context?: any): void { this._capture("visitCssValue", ast, context); }
+  visitCssValue(ast: any /** TODO #9100 */, context?: any): void { this._capture("visitCssValue", ast, context); }
 
-  visitInlineCssRule(ast, context?: any): void {
+  visitInlineCssRule(ast: any /** TODO #9100 */, context?: any): void {
     this._capture("visitInlineCssRule", ast, context);
   }
 
@@ -118,7 +118,7 @@ export function main() {
   }
 
   describe('CSS parsing and visiting', () => {
-    var ast;
+    var ast: any /** TODO #9100 */;
     var context = {};
 
     beforeEach(() => {
diff --git a/modules/@angular/compiler/test/directive_lifecycle_spec.ts b/modules/@angular/compiler/test/directive_lifecycle_spec.ts
index 257e01de8b..02dd8412b9 100644
--- a/modules/@angular/compiler/test/directive_lifecycle_spec.ts
+++ b/modules/@angular/compiler/test/directive_lifecycle_spec.ts
@@ -113,7 +113,7 @@ export function main() {
 class DirectiveNoHooks {}
 
 class DirectiveWithOnChangesMethod {
-  ngOnChanges(_) {}
+  ngOnChanges(_: any /** TODO #9100 */) {}
 }
 
 class DirectiveWithOnInitMethod {
diff --git a/modules/@angular/compiler/test/directive_normalizer_spec.ts b/modules/@angular/compiler/test/directive_normalizer_spec.ts
index 5a5bf6bcf5..2b93ad8e72 100644
--- a/modules/@angular/compiler/test/directive_normalizer_spec.ts
+++ b/modules/@angular/compiler/test/directive_normalizer_spec.ts
@@ -36,7 +36,7 @@ export function main() {
       describe('inline template', () => {
         it('should store the template',
            inject([AsyncTestCompleter, DirectiveNormalizer],
-                  (async, normalizer: DirectiveNormalizer) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer) => {
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
                                                    template: 'a',
@@ -53,7 +53,7 @@ export function main() {
 
         it('should resolve styles on the annotation against the moduleUrl',
            inject([AsyncTestCompleter, DirectiveNormalizer],
-                  (async, normalizer: DirectiveNormalizer) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer) => {
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
                                                    template: '',
@@ -69,7 +69,7 @@ export function main() {
 
         it('should resolve styles in the template against the moduleUrl',
            inject([AsyncTestCompleter, DirectiveNormalizer],
-                  (async, normalizer: DirectiveNormalizer) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer) => {
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
                                                    template: '<style>@import test.css</style>',
@@ -85,7 +85,7 @@ export function main() {
 
         it('should use ViewEncapsulation.Emulated by default',
            inject([AsyncTestCompleter, DirectiveNormalizer],
-                  (async, normalizer: DirectiveNormalizer) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer) => {
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
                                                    template: '',
@@ -101,7 +101,7 @@ export function main() {
 
         it('should use default encapsulation provided by CompilerConfig',
            inject([AsyncTestCompleter, CompilerConfig , DirectiveNormalizer],
-                  (async, config: CompilerConfig, normalizer: DirectiveNormalizer) => {
+                  (async: any /** TODO #9100 */, config: CompilerConfig, normalizer: DirectiveNormalizer) => {
                     config.defaultEncapsulation = ViewEncapsulation.None;
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
@@ -121,7 +121,7 @@ export function main() {
 
         it('should load a template from a url that is resolved against moduleUrl',
            inject([AsyncTestCompleter, DirectiveNormalizer, XHR],
-                  (async, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
                     xhr.expect('package:some/module/sometplurl.html', 'a');
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
@@ -141,7 +141,7 @@ export function main() {
 
         it('should resolve styles on the annotation against the moduleUrl',
            inject([AsyncTestCompleter, DirectiveNormalizer, XHR],
-                  (async, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
                     xhr.expect('package:some/module/tpl/sometplurl.html', '');
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
                                                    encapsulation: null,
@@ -159,7 +159,7 @@ export function main() {
 
         it('should resolve styles in the template against the templateUrl',
            inject([AsyncTestCompleter, DirectiveNormalizer, XHR],
-                  (async, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
+                  (async: any /** TODO #9100 */, normalizer: DirectiveNormalizer, xhr: MockXHR) => {
                     xhr.expect('package:some/module/tpl/sometplurl.html',
                                '<style>@import test.css</style>');
                     normalizer.normalizeTemplate(dirType, new CompileTemplateMetadata({
diff --git a/modules/@angular/compiler/test/directive_resolver_spec.ts b/modules/@angular/compiler/test/directive_resolver_spec.ts
index 2e2d4f3306..742e58123d 100644
--- a/modules/@angular/compiler/test/directive_resolver_spec.ts
+++ b/modules/@angular/compiler/test/directive_resolver_spec.ts
@@ -27,22 +27,22 @@ class SomeChildDirective extends SomeDirective {
 
 @Directive({selector: 'someDirective', inputs: ['c']})
 class SomeDirectiveWithInputs {
-  @Input() a;
-  @Input("renamed") b;
-  c;
+  @Input() a: any /** TODO #9100 */;
+  @Input("renamed") b: any /** TODO #9100 */;
+  c: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', outputs: ['c']})
 class SomeDirectiveWithOutputs {
-  @Output() a;
-  @Output("renamed") b;
-  c;
+  @Output() a: any /** TODO #9100 */;
+  @Output("renamed") b: any /** TODO #9100 */;
+  c: any /** TODO #9100 */;
 }
 
 
 @Directive({selector: 'someDirective', outputs: ['a']})
 class SomeDirectiveWithDuplicateOutputs {
-  @Output() a;
+  @Output() a: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', properties: ['a']})
@@ -56,23 +56,23 @@ class SomeDirectiveWithEvents {
 @Directive({selector: 'someDirective'})
 class SomeDirectiveWithSetterProps {
   @Input("renamed")
-  set a(value) {
+  set a(value: any /** TODO #9100 */) {
   }
 }
 
 @Directive({selector: 'someDirective'})
 class SomeDirectiveWithGetterOutputs {
   @Output("renamed")
-  get a() {
+  get a(): any /** TODO #9100 */ {
     return null;
   }
 }
 
 @Directive({selector: 'someDirective', host: {'[c]': 'c'}})
 class SomeDirectiveWithHostBindings {
-  @HostBinding() a;
-  @HostBinding("renamed") b;
-  c;
+  @HostBinding() a: any /** TODO #9100 */;
+  @HostBinding("renamed") b: any /** TODO #9100 */;
+  c: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', host: {'(c)': 'onC()'}})
@@ -81,32 +81,32 @@ class SomeDirectiveWithHostListeners {
   onA() {
   }
   @HostListener('b', ['$event.value'])
-  onB(value) {
+  onB(value: any /** TODO #9100 */) {
   }
 }
 
 @Directive({selector: 'someDirective', queries: {"cs": new ContentChildren("c")}})
 class SomeDirectiveWithContentChildren {
   @ContentChildren("a") as: any;
-  c;
+  c: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', queries: {"cs": new ViewChildren("c")}})
 class SomeDirectiveWithViewChildren {
   @ViewChildren("a") as: any;
-  c;
+  c: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', queries: {"c": new ContentChild("c")}})
 class SomeDirectiveWithContentChild {
   @ContentChild("a") a: any;
-  c;
+  c: any /** TODO #9100 */;
 }
 
 @Directive({selector: 'someDirective', queries: {"c": new ViewChild("c")}})
 class SomeDirectiveWithViewChild {
   @ViewChild("a") a: any;
-  c;
+  c: any /** TODO #9100 */;
 }
 
 class SomeDirectiveWithoutMetadata {}
diff --git a/modules/@angular/compiler/test/expression_parser/lexer_spec.ts b/modules/@angular/compiler/test/expression_parser/lexer_spec.ts
index f402d193bb..4cb65da08f 100644
--- a/modules/@angular/compiler/test/expression_parser/lexer_spec.ts
+++ b/modules/@angular/compiler/test/expression_parser/lexer_spec.ts
@@ -8,41 +8,41 @@ function lex(text: string): any[] {
   return new Lexer().tokenize(text);
 }
 
-function expectToken(token, index) {
+function expectToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */) {
   expect(token instanceof Token).toBe(true);
   expect(token.index).toEqual(index);
 }
 
-function expectCharacterToken(token, index, character) {
+function expectCharacterToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, character: any /** TODO #9100 */) {
   expect(character.length).toBe(1);
   expectToken(token, index);
   expect(token.isCharacter(StringWrapper.charCodeAt(character, 0))).toBe(true);
 }
 
-function expectOperatorToken(token, index, operator) {
+function expectOperatorToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, operator: any /** TODO #9100 */) {
   expectToken(token, index);
   expect(token.isOperator(operator)).toBe(true);
 }
 
-function expectNumberToken(token, index, n) {
+function expectNumberToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, n: any /** TODO #9100 */) {
   expectToken(token, index);
   expect(token.isNumber()).toBe(true);
   expect(token.toNumber()).toEqual(n);
 }
 
-function expectStringToken(token, index, str) {
+function expectStringToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, str: any /** TODO #9100 */) {
   expectToken(token, index);
   expect(token.isString()).toBe(true);
   expect(token.toString()).toEqual(str);
 }
 
-function expectIdentifierToken(token, index, identifier) {
+function expectIdentifierToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, identifier: any /** TODO #9100 */) {
   expectToken(token, index);
   expect(token.isIdentifier()).toBe(true);
   expect(token.toString()).toEqual(identifier);
 }
 
-function expectKeywordToken(token, index, keyword) {
+function expectKeywordToken(token: any /** TODO #9100 */, index: any /** TODO #9100 */, keyword: any /** TODO #9100 */) {
   expectToken(token, index);
   expect(token.isKeyword()).toBe(true);
   expect(token.toString()).toEqual(keyword);
diff --git a/modules/@angular/compiler/test/expression_parser/parser_spec.ts b/modules/@angular/compiler/test/expression_parser/parser_spec.ts
index de3c298905..4b876aa909 100644
--- a/modules/@angular/compiler/test/expression_parser/parser_spec.ts
+++ b/modules/@angular/compiler/test/expression_parser/parser_spec.ts
@@ -8,23 +8,23 @@ import {BindingPipe, LiteralPrimitive, AST} from '@angular/compiler/src/expressi
 export function main() {
   function createParser() { return new Parser(new Lexer()); }
 
-  function parseAction(text, location = null): any {
+  function parseAction(text: any /** TODO #9100 */, location: any /** TODO #9100 */ = null): any {
     return createParser().parseAction(text, location);
   }
 
-  function parseBinding(text, location = null): any {
+  function parseBinding(text: any /** TODO #9100 */, location: any /** TODO #9100 */ = null): any {
     return createParser().parseBinding(text, location);
   }
 
-  function parseTemplateBindings(text, location = null): any {
+  function parseTemplateBindings(text: any /** TODO #9100 */, location: any /** TODO #9100 */ = null): any {
     return createParser().parseTemplateBindings(text, location).templateBindings;
   }
 
-  function parseInterpolation(text, location = null): any {
+  function parseInterpolation(text: any /** TODO #9100 */, location: any /** TODO #9100 */ = null): any {
     return createParser().parseInterpolation(text, location);
   }
 
-  function parseSimpleBinding(text, location = null): any {
+  function parseSimpleBinding(text: any /** TODO #9100 */, location: any /** TODO #9100 */ = null): any {
     return createParser().parseSimpleBinding(text, location);
   }
 
@@ -48,9 +48,9 @@ export function main() {
     expect(unparse(ast)).toEqual(expected);
   }
 
-  function expectActionError(text) { return expect(() => parseAction(text)); }
+  function expectActionError(text: any /** TODO #9100 */) { return expect(() => parseAction(text)); }
 
-  function expectBindingError(text) { return expect(() => parseBinding(text)); }
+  function expectBindingError(text: any /** TODO #9100 */) { return expect(() => parseBinding(text)); }
 
   describe("parser", () => {
     describe("parseAction", () => {
diff --git a/modules/@angular/compiler/test/i18n/i18n_html_parser_spec.ts b/modules/@angular/compiler/test/i18n/i18n_html_parser_spec.ts
index 6e4d59703b..10f30e2e7f 100644
--- a/modules/@angular/compiler/test/i18n/i18n_html_parser_spec.ts
+++ b/modules/@angular/compiler/test/i18n/i18n_html_parser_spec.ts
@@ -18,7 +18,7 @@ export function main() {
       let htmlParser = new HtmlParser();
 
       let msgs = '';
-      StringMapWrapper.forEach(messages, (v, k) => msgs += `<msg id="${k}">${v}</msg>`);
+      StringMapWrapper.forEach(messages, (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => msgs += `<msg id="${k}">${v}</msg>`);
       let res = deserializeXmb(`<message-bundle>${msgs}</message-bundle>`, 'someUrl');
 
       return new I18nHtmlParser(htmlParser, parser, res.content, res.messages, implicitTags,
diff --git a/modules/@angular/compiler/test/offline_compiler_spec.ts b/modules/@angular/compiler/test/offline_compiler_spec.ts
index 0784a62db1..dc9da1b1ef 100644
--- a/modules/@angular/compiler/test/offline_compiler_spec.ts
+++ b/modules/@angular/compiler/test/offline_compiler_spec.ts
@@ -43,7 +43,7 @@ export function main() {
     var injector: Injector;
     var sharedStylesHost: SharedStylesHost;
 
-    beforeEach(inject([Injector, SharedStylesHost], (_injector, _sharedStylesHost) => {
+    beforeEach(inject([Injector, SharedStylesHost], (_injector: any /** TODO #9100 */, _sharedStylesHost: any /** TODO #9100 */) => {
       injector = _injector;
       sharedStylesHost = _sharedStylesHost;
     }));
diff --git a/modules/@angular/compiler/test/output/output_emitter_spec.ts b/modules/@angular/compiler/test/output/output_emitter_spec.ts
index 81d044f829..3b0bd539c3 100644
--- a/modules/@angular/compiler/test/output/output_emitter_spec.ts
+++ b/modules/@angular/compiler/test/output/output_emitter_spec.ts
@@ -26,7 +26,7 @@ import {
 
     export function
     main() {
-  var outputDefs = [];
+  var outputDefs: any[] /** TODO #9100 */ = [];
   outputDefs.push({
     'getExpressions': () => interpretStatements(codegenStmts, 'getExpressions',
                                                 new DynamicClassInstanceFactory()),
@@ -50,7 +50,7 @@ import {
   describe('output emitter', () => {
     outputDefs.forEach((outputDef) => {
       describe(`${outputDef['name']}`, () => {
-        var expressions;
+        var expressions: any /** TODO #9100 */;
         beforeEach(() => { expressions = outputDef['getExpressions']()(); });
 
         it('should support literals', () => {
@@ -116,8 +116,8 @@ import {
         });
 
         describe('operators', () => {
-          var ops;
-          var aObj, bObj;
+          var ops: any /** TODO #9100 */;
+          var aObj: any /** TODO #9100 */, bObj: any /** TODO #9100 */;
           beforeEach(() => {
             ops = expressions['operators'];
             aObj = new Object();
diff --git a/modules/@angular/compiler/test/output/output_emitter_util.ts b/modules/@angular/compiler/test/output/output_emitter_util.ts
index 6dd8553882..6d5425e1ba 100644
--- a/modules/@angular/compiler/test/output/output_emitter_util.ts
+++ b/modules/@angular/compiler/test/output/output_emitter_util.ts
@@ -10,7 +10,7 @@ import * as o from '@angular/compiler/src/output/output_ast';
 export class ExternalClass {
   changeable: any;
   constructor(public data: any) { this.changeable = data; }
-  someMethod(a) { return {'param': a, 'data': this.data}; }
+  someMethod(a: any /** TODO #9100 */) { return {'param': a, 'data': this.data}; }
 }
 
 var testDataIdentifier = new CompileIdentifierMetadata({
@@ -271,5 +271,5 @@ class _InterpretiveDynamicClass extends ExternalClass implements DynamicInstance
               public getters: Map<string, Function>, public methods: Map<string, Function>) {
     super(args[0]);
   }
-  childMethod(a) { return this.methods.get('childMethod')(a); }
+  childMethod(a: any /** TODO #9100 */) { return this.methods.get('childMethod')(a); }
 }
diff --git a/modules/@angular/compiler/test/schema/schema_extractor.ts b/modules/@angular/compiler/test/schema/schema_extractor.ts
index ead3700772..1db80fd481 100644
--- a/modules/@angular/compiler/test/schema/schema_extractor.ts
+++ b/modules/@angular/compiler/test/schema/schema_extractor.ts
@@ -2,16 +2,16 @@ import {isString, isPresent} from '../../src/facade/lang';
 
 const SVG_PREFIX = ':svg:';
 
-var document = typeof global['document'] == 'object' ? global['document'] : null;
+var document = typeof (global as any /** TODO #???? */)['document'] == 'object' ? (global as any /** TODO #???? */)['document'] : null;
 
 export function extractSchema(): Map<string, string[]> {
-  var SVGGraphicsElement = global['SVGGraphicsElement'];
-  var SVGAnimationElement = global['SVGAnimationElement'];
-  var SVGGeometryElement = global['SVGGeometryElement'];
-  var SVGComponentTransferFunctionElement = global['SVGComponentTransferFunctionElement'];
-  var SVGGradientElement = global['SVGGradientElement'];
-  var SVGTextContentElement = global['SVGTextContentElement'];
-  var SVGTextPositioningElement = global['SVGTextPositioningElement'];
+  var SVGGraphicsElement = (global as any /** TODO #???? */)['SVGGraphicsElement'];
+  var SVGAnimationElement = (global as any /** TODO #???? */)['SVGAnimationElement'];
+  var SVGGeometryElement = (global as any /** TODO #???? */)['SVGGeometryElement'];
+  var SVGComponentTransferFunctionElement = (global as any /** TODO #???? */)['SVGComponentTransferFunctionElement'];
+  var SVGGradientElement = (global as any /** TODO #???? */)['SVGGradientElement'];
+  var SVGTextContentElement = (global as any /** TODO #???? */)['SVGTextContentElement'];
+  var SVGTextPositioningElement = (global as any /** TODO #???? */)['SVGTextPositioningElement'];
   if (!document || !SVGGraphicsElement) return null;
   var descMap: Map<string, string[]> = new Map();
   var visited: {[name: string]: boolean} = {};
@@ -44,7 +44,7 @@ export function extractSchema(): Map<string, string[]> {
   var keys = Object.getOwnPropertyNames(window).filter(
       k => k.endsWith('Element') && (k.startsWith('HTML') || k.startsWith('SVG')));
   keys.sort();
-  keys.forEach(name => extractRecursiveProperties(visited, descMap, window[name]));
+  keys.forEach(name => extractRecursiveProperties(visited, descMap, (window as any /** TODO #???? */)[name]));
 
   return descMap;
 }
diff --git a/modules/@angular/compiler/test/selector_spec.ts b/modules/@angular/compiler/test/selector_spec.ts
index f198ce094a..7050c922fa 100644
--- a/modules/@angular/compiler/test/selector_spec.ts
+++ b/modules/@angular/compiler/test/selector_spec.ts
@@ -6,7 +6,7 @@ import {el} from '@angular/platform-browser/testing';
 
 export function main() {
   describe('SelectorMatcher', () => {
-    var matcher, selectableCollector, s1, s2, s3, s4;
+    var matcher: any /** TODO #9100 */, selectableCollector: any /** TODO #9100 */, s1: any /** TODO #9100 */, s2: any /** TODO #9100 */, s3: any /** TODO #9100 */, s4: any /** TODO #9100 */;
     var matched: any[];
 
     function reset() { matched = []; }
@@ -14,7 +14,7 @@ export function main() {
     beforeEach(() => {
       reset();
       s1 = s2 = s3 = s4 = null;
-      selectableCollector = (selector, context) => {
+      selectableCollector = (selector: any /** TODO #9100 */, context: any /** TODO #9100 */) => {
         matched.push(selector);
         matched.push(context);
       };
diff --git a/modules/@angular/compiler/test/shadow_css_spec.ts b/modules/@angular/compiler/test/shadow_css_spec.ts
index ee07bf40ea..7d69361169 100644
--- a/modules/@angular/compiler/test/shadow_css_spec.ts
+++ b/modules/@angular/compiler/test/shadow_css_spec.ts
@@ -186,8 +186,8 @@ export function main() {
   describe('processRules', () => {
     describe('parse rules', () => {
       function captureRules(input: string): CssRule[] {
-        var result = [];
-        processRules(input, (cssRule) => {
+        var result: any[] /** TODO #9100 */ = [];
+        processRules(input, (cssRule: any /** TODO #9100 */) => {
           result.push(cssRule);
           return cssRule;
         });
@@ -216,13 +216,13 @@ export function main() {
     describe('modify rules', () => {
       it('should allow to change the selector while preserving whitespaces', () => {
         expect(processRules('@import a; b {c {d}} e {f}',
-                            (cssRule) => new CssRule(cssRule.selector + '2', cssRule.content)))
+                            (cssRule: any /** TODO #9100 */) => new CssRule(cssRule.selector + '2', cssRule.content)))
             .toEqual('@import a2; b2 {c {d}} e2 {f}');
       });
 
       it('should allow to change the content', () => {
         expect(processRules('a {b}',
-                            (cssRule) => new CssRule(cssRule.selector, cssRule.content + '2')))
+                            (cssRule: any /** TODO #9100 */) => new CssRule(cssRule.selector, cssRule.content + '2')))
             .toEqual('a {b2}');
       });
     });
diff --git a/modules/@angular/compiler/test/style_url_resolver_spec.ts b/modules/@angular/compiler/test/style_url_resolver_spec.ts
index 3c5dac6efb..a010e0120d 100644
--- a/modules/@angular/compiler/test/style_url_resolver_spec.ts
+++ b/modules/@angular/compiler/test/style_url_resolver_spec.ts
@@ -5,7 +5,7 @@ import {UrlResolver} from '@angular/compiler/src/url_resolver';
 
 export function main() {
   describe('extractStyleUrls', () => {
-    var urlResolver;
+    var urlResolver: any /** TODO #9100 */;
 
     beforeEach(() => { urlResolver = new UrlResolver(); });
 
diff --git a/modules/@angular/compiler/test/template_parser_spec.ts b/modules/@angular/compiler/test/template_parser_spec.ts
index 3248d6c26d..0c09365066 100644
--- a/modules/@angular/compiler/test/template_parser_spec.ts
+++ b/modules/@angular/compiler/test/template_parser_spec.ts
@@ -71,7 +71,7 @@ var MOCK_SCHEMA_REGISTRY = [
 let zeConsole = console;
 
 export function main() {
-  var ngIf;
+  var ngIf: any /** TODO #9100 */;
   var parse:
       (template: string, directives: CompileDirectiveMetadata[], pipes?: CompilePipeMetadata[]) =>
           TemplateAst[];
@@ -82,7 +82,7 @@ export function main() {
       console = new ArrayConsole();
       return [{provide: Console, useValue: console}];
     });
-    beforeEach(inject([TemplateParser], (parser) => {
+    beforeEach(inject([TemplateParser], (parser: any /** TODO #9100 */) => {
       var component = CompileDirectiveMetadata.create({
         selector: 'root',
         type: new CompileTypeMetadata({moduleUrl: someModuleUrl, name: 'Root'}),
@@ -518,10 +518,10 @@ export function main() {
       });
 
       describe('providers', () => {
-        var nextProviderId;
+        var nextProviderId: any /** TODO #9100 */;
 
         function createToken(value: string): CompileTokenMetadata {
-          var token;
+          var token: any /** TODO #9100 */;
           if (value.startsWith('type:')) {
             token = new CompileTokenMetadata({
               identifier:
@@ -1071,7 +1071,7 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
     });
 
     describe('content projection', () => {
-      var compCounter;
+      var compCounter: any /** TODO #9100 */;
       beforeEach(() => { compCounter = 0; });
 
       function createComp(selector: string,
diff --git a/modules/@angular/compiler/test/template_preparser_spec.ts b/modules/@angular/compiler/test/template_preparser_spec.ts
index a230eb481e..c164f2768c 100644
--- a/modules/@angular/compiler/test/template_preparser_spec.ts
+++ b/modules/@angular/compiler/test/template_preparser_spec.ts
@@ -21,7 +21,7 @@ import {
 
 export function main() {
   describe('preparseElement', () => {
-    var htmlParser;
+    var htmlParser: any /** TODO #9100 */;
     beforeEach(inject([HtmlParser], (_htmlParser: HtmlParser) => { htmlParser = _htmlParser; }));
 
     function preparse(html: string): PreparsedElement {
diff --git a/modules/@angular/compiler/test/test_component_builder_spec.ts b/modules/@angular/compiler/test/test_component_builder_spec.ts
index 542df542e0..b06a349f87 100644
--- a/modules/@angular/compiler/test/test_component_builder_spec.ts
+++ b/modules/@angular/compiler/test/test_component_builder_spec.ts
@@ -192,7 +192,7 @@ class DirectiveListComp {
 export function main() {
   describe('test component builder', function() {
     it('should instantiate a component with valid DOM',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(ChildComp).then((componentFixture) => {
            componentFixture.detectChanges();
@@ -203,7 +203,7 @@ export function main() {
        }));
 
     it('should allow changing members of the component',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(MyIfComp).then((componentFixture) => {
            componentFixture.detectChanges();
@@ -218,7 +218,7 @@ export function main() {
        }));
 
     it('should override a template',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideTemplate(MockChildComp, '<span>Mock</span>')
              .createAsync(MockChildComp)
@@ -231,7 +231,7 @@ export function main() {
        }));
 
     it('should override a view',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideView(ChildComp,
                           new ViewMetadata({template: '<span>Modified {{childBinding}}</span>'}))
@@ -245,7 +245,7 @@ export function main() {
        }));
 
     it('should override component dependencies',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideDirective(ParentComp, ChildComp, MockChildComp)
              .createAsync(ParentComp)
@@ -258,7 +258,7 @@ export function main() {
        }));
 
     it('should override items from a list',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideDirective(DirectiveListComp, ListDir1, ListDir1Alt)
              .createAsync(DirectiveListComp)
@@ -271,7 +271,7 @@ export function main() {
        }));
 
     it("should override child component's dependencies",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideDirective(ParentComp, ChildComp, ChildWithChildComp)
              .overrideDirective(ChildWithChildComp, ChildChildComp, MockChildChildComp)
@@ -286,7 +286,7 @@ export function main() {
        }));
 
     it('should override a provider',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideProviders(TestBindingsComp,
                                [{provide: FancyService, useClass: MockFancyService}])
@@ -301,7 +301,7 @@ export function main() {
 
 
     it('should override a viewBinding',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideViewProviders(TestViewBindingsComp,
                                    [{provide: FancyService, useClass: MockFancyService}])
@@ -318,7 +318,7 @@ export function main() {
       describe('ComponentFixture', () => {
         it('should auto detect changes if autoDetectChanges is called',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AutoDetectComp)
                         .then((componentFixture) => {
@@ -338,7 +338,7 @@ export function main() {
         it('should auto detect changes if ComponentFixtureAutoDetect is provided as true',
            withProviders(() => [{provide: ComponentFixtureAutoDetect, useValue: true}])
                .inject([TestComponentBuilder, AsyncTestCompleter],
-                       (tcb: TestComponentBuilder, async) => {
+                       (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                          tcb.createAsync(AutoDetectComp)
                              .then((componentFixture) => {
@@ -354,7 +354,7 @@ export function main() {
 
         it('should signal through whenStable when the fixture is stable (autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncComp).then((componentFixture) => {
                       componentFixture.autoDetectChanges();
@@ -377,7 +377,7 @@ export function main() {
 
         it('should signal through isStable when the fixture is stable (no autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncComp).then((componentFixture) => {
                       componentFixture.detectChanges();
@@ -401,7 +401,7 @@ export function main() {
         it('should wait for macroTask(setTimeout) while checking for whenStable ' +
                '(autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncTimeoutComp)
                         .then((componentFixture) => {
@@ -426,7 +426,7 @@ export function main() {
         it('should wait for macroTask(setTimeout) while checking for whenStable ' +
                '(no autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncTimeoutComp)
                         .then((componentFixture) => {
@@ -452,7 +452,7 @@ export function main() {
         it('should wait for nested macroTasks(setTimeout) while checking for whenStable ' +
                '(autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(NestedAsyncTimeoutComp)
                         .then((componentFixture) => {
@@ -477,7 +477,7 @@ export function main() {
         it('should wait for nested macroTasks(setTimeout) while checking for whenStable ' +
                '(no autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(NestedAsyncTimeoutComp)
                         .then((componentFixture) => {
@@ -502,7 +502,7 @@ export function main() {
 
         it('should stabilize after async task in change detection (autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncChangeComp)
                         .then((componentFixture) => {
@@ -523,7 +523,7 @@ export function main() {
 
         it('should stabilize after async task in change detection(no autoDetectChanges)',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.createAsync(AsyncChangeComp)
                         .then((componentFixture) => {
@@ -554,7 +554,7 @@ export function main() {
 
           it('calling autoDetectChanges raises an error', () => {
             inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                                async) => {
+                                                                async: any /** TODO #9100 */) => {
               tcb.createAsync(ChildComp).then((componentFixture) => {
                 expect(() => {
                   componentFixture.autoDetectChanges();
@@ -566,7 +566,7 @@ export function main() {
 
           it('should instantiate a component with valid DOM',
              inject([TestComponentBuilder, AsyncTestCompleter],
-                    (tcb: TestComponentBuilder, async) => {
+                    (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                       tcb.createAsync(ChildComp).then((componentFixture) => {
                         expect(componentFixture.ngZone).toBeNull();
@@ -578,7 +578,7 @@ export function main() {
 
           it('should allow changing members of the component',
              inject([TestComponentBuilder, AsyncTestCompleter],
-                    (tcb: TestComponentBuilder, async) => {
+                    (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                       tcb.createAsync(MyIfComp).then((componentFixture) => {
                         componentFixture.detectChanges();
@@ -596,7 +596,7 @@ export function main() {
         describe('createSync', () => {
           it('should create components',
              inject([ComponentResolver, TestComponentBuilder, AsyncTestCompleter],
-                    (cr: ComponentResolver, tcb: TestComponentBuilder, async) => {
+                    (cr: ComponentResolver, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                       cr.resolveComponent(MyIfComp).then((cmpFactory) => {
                         let componentFixture = tcb.createSync(cmpFactory);
 
diff --git a/modules/@angular/compiler/test/xhr_mock_spec.ts b/modules/@angular/compiler/test/xhr_mock_spec.ts
index 57756eac19..300d92ba91 100644
--- a/modules/@angular/compiler/test/xhr_mock_spec.ts
+++ b/modules/@angular/compiler/test/xhr_mock_spec.ts
@@ -18,7 +18,7 @@ export function main() {
 
     beforeEach(() => { xhr = new MockXHR(); });
 
-    function expectResponse(request: Promise<string>, url: string, response: string, done = null) {
+    function expectResponse(request: Promise<string>, url: string, response: string, done: any /** TODO #9100 */ = null) {
       function onResponse(text: string): string {
         if (response === null) {
           throw `Unexpected response ${url} -> ${text}`;
@@ -42,7 +42,7 @@ export function main() {
       PromiseWrapper.then(request, onResponse, onError);
     }
 
-    it('should return a response from the definitions', inject([AsyncTestCompleter], (async) => {
+    it('should return a response from the definitions', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var url = '/foo';
          var response = 'bar';
          xhr.when(url, response);
@@ -50,15 +50,15 @@ export function main() {
          xhr.flush();
        }));
 
-    it('should return an error from the definitions', inject([AsyncTestCompleter], (async) => {
+    it('should return an error from the definitions', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var url = '/foo';
-         var response = null;
+         var response: any /** TODO #9100 */ = null;
          xhr.when(url, response);
          expectResponse(xhr.get(url), url, response, () => async.done());
          xhr.flush();
        }));
 
-    it('should return a response from the expectations', inject([AsyncTestCompleter], (async) => {
+    it('should return a response from the expectations', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var url = '/foo';
          var response = 'bar';
          xhr.expect(url, response);
@@ -66,9 +66,9 @@ export function main() {
          xhr.flush();
        }));
 
-    it('should return an error from the expectations', inject([AsyncTestCompleter], (async) => {
+    it('should return an error from the expectations', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var url = '/foo';
-         var response = null;
+         var response: any /** TODO #9100 */ = null;
          xhr.expect(url, response);
          expectResponse(xhr.get(url), url, response, () => async.done());
          xhr.flush();
@@ -83,7 +83,7 @@ export function main() {
       expect(() => { xhr.flush(); }).toThrowError('Unexpected request /foo');
     });
 
-    it('should return expectations before definitions', inject([AsyncTestCompleter], (async) => {
+    it('should return expectations before definitions', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var url = '/foo';
          xhr.when(url, 'when');
          xhr.expect(url, 'expect');
diff --git a/modules/@angular/compiler/testing/test_component_builder.ts b/modules/@angular/compiler/testing/test_component_builder.ts
index 543bda9794..01b33a840e 100644
--- a/modules/@angular/compiler/testing/test_component_builder.ts
+++ b/modules/@angular/compiler/testing/test_component_builder.ts
@@ -75,10 +75,10 @@ export class ComponentFixture<T> {
 
   private _isStable: boolean = true;
   private _completer: PromiseCompleter<any> = null;
-  private _onUnstableSubscription = null;
-  private _onStableSubscription = null;
-  private _onMicrotaskEmptySubscription = null;
-  private _onErrorSubscription = null;
+  private _onUnstableSubscription: any /** TODO #9100 */ = null;
+  private _onStableSubscription: any /** TODO #9100 */ = null;
+  private _onMicrotaskEmptySubscription: any /** TODO #9100 */ = null;
+  private _onErrorSubscription: any /** TODO #9100 */ = null;
 
   constructor(componentRef: ComponentRef<T>, ngZone: NgZone, autoDetect: boolean) {
     this.changeDetectorRef = componentRef.changeDetectorRef;
@@ -368,8 +368,8 @@ export class TestComponentBuilder {
   }
 
   createFakeAsync(rootComponentType: Type): ComponentFixture<any> {
-    let result;
-    let error;
+    let result: any /** TODO #9100 */;
+    let error: any /** TODO #9100 */;
     PromiseWrapper.then(this.createAsync(rootComponentType), (_result) => { result = _result; },
                         (_error) => { error = _error; });
     tick();
diff --git a/modules/@angular/compiler/testing/view_resolver_mock.ts b/modules/@angular/compiler/testing/view_resolver_mock.ts
index 3829450b12..45b3d6b9e6 100644
--- a/modules/@angular/compiler/testing/view_resolver_mock.ts
+++ b/modules/@angular/compiler/testing/view_resolver_mock.ts
@@ -71,7 +71,7 @@ export class MockViewResolver extends ViewResolver {
       view = super.resolve(component);
     }
 
-    var directives = [];
+    var directives: any[] /** TODO #9100 */ = [];
     if (isPresent(view.directives)) {
       flattenArray(view.directives, directives);
     }
diff --git a/modules/@angular/compiler/testing/xhr_mock.ts b/modules/@angular/compiler/testing/xhr_mock.ts
index 559af14356..cc53922ad9 100644
--- a/modules/@angular/compiler/testing/xhr_mock.ts
+++ b/modules/@angular/compiler/testing/xhr_mock.ts
@@ -61,7 +61,7 @@ export class MockXHR extends XHR {
   verifyNoOutstandingExpectations() {
     if (this._expectations.length === 0) return;
 
-    var urls = [];
+    var urls: any[] /** TODO #9100 */ = [];
     for (var i = 0; i < this._expectations.length; i++) {
       var expectation = this._expectations[i];
       urls.push(expectation.url);
@@ -96,7 +96,7 @@ class _PendingRequest {
   url: string;
   completer: PromiseCompleter<string>;
 
-  constructor(url) {
+  constructor(url: any /** TODO #9100 */) {
     this.url = url;
     this.completer = PromiseWrapper.completer();
   }
diff --git a/modules/@angular/core/src/animation/active_animation_players_map.ts b/modules/@angular/core/src/animation/active_animation_players_map.ts
index 085c19edad..0cef45092e 100644
--- a/modules/@angular/core/src/animation/active_animation_players_map.ts
+++ b/modules/@angular/core/src/animation/active_animation_players_map.ts
@@ -18,8 +18,8 @@ export class ActiveAnimationPlayersMap {
   }
 
   findAllPlayersByElement(element: any): AnimationPlayer[] {
-    var players = [];
-    StringMapWrapper.forEach(this._map.get(element), player => players.push(player));
+    var players: any[] /** TODO #9100 */ = [];
+    StringMapWrapper.forEach(this._map.get(element), (player: any /** TODO #9100 */) => players.push(player));
     return players;
   }
 
diff --git a/modules/@angular/core/src/animation/animation_group_player.ts b/modules/@angular/core/src/animation/animation_group_player.ts
index 4d34bc6f7b..58a2046d4c 100644
--- a/modules/@angular/core/src/animation/animation_group_player.ts
+++ b/modules/@angular/core/src/animation/animation_group_player.ts
@@ -55,7 +55,7 @@ export class AnimationGroupPlayer implements AnimationPlayer {
 
   reset(): void { this._players.forEach(player => player.reset()); }
 
-  setPosition(p): void {
+  setPosition(p: any /** TODO #9100 */): void {
     this._players.forEach(player => {
       player.setPosition(p);
     });
diff --git a/modules/@angular/core/src/animation/animation_player.ts b/modules/@angular/core/src/animation/animation_player.ts
index a3f2e9301f..171a120bc0 100644
--- a/modules/@angular/core/src/animation/animation_player.ts
+++ b/modules/@angular/core/src/animation/animation_player.ts
@@ -9,7 +9,7 @@ export abstract class AnimationPlayer {
   abstract finish(): void;
   abstract destroy(): void;
   abstract reset(): void;
-  abstract setPosition(p): void;
+  abstract setPosition(p: any /** TODO #9100 */): void;
   abstract getPosition(): number;
   get parentPlayer(): AnimationPlayer { throw new BaseException('NOT IMPLEMENTED: Base Class'); }
   set parentPlayer(player: AnimationPlayer) { throw new BaseException('NOT IMPLEMENTED: Base Class'); }
@@ -17,7 +17,7 @@ export abstract class AnimationPlayer {
 
 export class NoOpAnimationPlayer implements AnimationPlayer {
   
-  private _subscriptions = [];
+  private _subscriptions: any[] /** TODO #9100 */ = [];
   public parentPlayer: AnimationPlayer = null;
   constructor() {
     scheduleMicroTask(() => this._onFinish());
@@ -36,6 +36,6 @@ export class NoOpAnimationPlayer implements AnimationPlayer {
   }
   destroy(): void {}
   reset(): void {}
-  setPosition(p): void {}
+  setPosition(p: any /** TODO #9100 */): void {}
   getPosition(): number { return 0; }
 }
diff --git a/modules/@angular/core/src/animation/animation_sequence_player.ts b/modules/@angular/core/src/animation/animation_sequence_player.ts
index 94f4c25a15..a8d67c2a03 100644
--- a/modules/@angular/core/src/animation/animation_sequence_player.ts
+++ b/modules/@angular/core/src/animation/animation_sequence_player.ts
@@ -72,7 +72,7 @@ export class AnimationSequencePlayer implements AnimationPlayer {
     this._players.forEach(player => player.destroy());
   }
 
-  setPosition(p): void {
+  setPosition(p: any /** TODO #9100 */): void {
     this._players[0].setPosition(p);
   }
 
diff --git a/modules/@angular/core/src/animation/animation_style_util.ts b/modules/@angular/core/src/animation/animation_style_util.ts
index 71ca75feee..a22db9d3d0 100644
--- a/modules/@angular/core/src/animation/animation_style_util.ts
+++ b/modules/@angular/core/src/animation/animation_style_util.ts
@@ -5,14 +5,14 @@ import {FILL_STYLE_FLAG} from './animation_constants';
 
 export function balanceAnimationStyles(previousStyles: {[key: string]: string|number},
                      newStyles: {[key: string]: string|number},
-                     nullValue = null): {[key: string]: string} {
+                     nullValue: any /** TODO #9100 */ = null): {[key: string]: string} {
   var finalStyles: {[key: string]: string} = {};
 
-  StringMapWrapper.forEach(newStyles, (value, prop) => {
+  StringMapWrapper.forEach(newStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
     finalStyles[prop] = value.toString();
   });
 
-  StringMapWrapper.forEach(previousStyles, (value, prop) => {
+  StringMapWrapper.forEach(previousStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
     if (!isPresent(finalStyles[prop])) {
       finalStyles[prop] = nullValue;
     }
@@ -32,12 +32,12 @@ export function balanceAnimationKeyframes(collectedStyles: {[key: string]: strin
 
   var extraFirstKeyframeStyles = {};
   var hasExtraFirstStyles = false;
-  StringMapWrapper.forEach(collectedStyles, (value, prop) => {
+  StringMapWrapper.forEach(collectedStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
     // if the style is already defined in the first keyframe then
     // we do not replace it.
-    if (!flatenedFirstKeyframeStyles[prop]) {
-      flatenedFirstKeyframeStyles[prop] = value;
-      extraFirstKeyframeStyles[prop] = value;
+    if (!(flatenedFirstKeyframeStyles as any /** TODO #9100 */)[prop]) {
+      (flatenedFirstKeyframeStyles as any /** TODO #9100 */)[prop] = value;
+      (extraFirstKeyframeStyles as any /** TODO #9100 */)[prop] = value;
       hasExtraFirstStyles = true;
     }
   });
@@ -51,9 +51,9 @@ export function balanceAnimationKeyframes(collectedStyles: {[key: string]: strin
   var flatenedFinalKeyframeStyles = flattenStyles(finalKeyframe.styles.styles);
   var extraFinalKeyframeStyles = {};
   var hasExtraFinalStyles = false;
-  StringMapWrapper.forEach(keyframeCollectedStyles, (value, prop) => {
-    if (!isPresent(flatenedFinalKeyframeStyles[prop])) {
-      extraFinalKeyframeStyles[prop] = AUTO_STYLE;
+  StringMapWrapper.forEach(keyframeCollectedStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
+    if (!isPresent((flatenedFinalKeyframeStyles as any /** TODO #9100 */)[prop])) {
+      (extraFinalKeyframeStyles as any /** TODO #9100 */)[prop] = AUTO_STYLE;
       hasExtraFinalStyles = true;
     }
   });
@@ -62,9 +62,9 @@ export function balanceAnimationKeyframes(collectedStyles: {[key: string]: strin
     finalKeyframe.styles.styles.push(extraFinalKeyframeStyles);
   }
 
-  StringMapWrapper.forEach(flatenedFinalKeyframeStyles, (value, prop) => {
-    if (!isPresent(flatenedFirstKeyframeStyles[prop])) {
-      extraFirstKeyframeStyles[prop] = AUTO_STYLE;
+  StringMapWrapper.forEach(flatenedFinalKeyframeStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
+    if (!isPresent((flatenedFirstKeyframeStyles as any /** TODO #9100 */)[prop])) {
+      (extraFirstKeyframeStyles as any /** TODO #9100 */)[prop] = AUTO_STYLE;
       hasExtraFirstStyles = true;
     }
   });
@@ -87,7 +87,7 @@ export function clearStyles(styles: {[key: string]: string|number}): {[key: stri
 export function collectAndResolveStyles(collection: {[key: string]: string|number}, styles: {[key: string]: string|number}[]) {
   return styles.map(entry => {
     var stylesObj = {};
-    StringMapWrapper.forEach(entry, (value, prop) => {
+    StringMapWrapper.forEach(entry, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
       if (value == FILL_STYLE_FLAG) {
         value = collection[prop];
         if (!isPresent(value)) {
@@ -95,14 +95,14 @@ export function collectAndResolveStyles(collection: {[key: string]: string|numbe
         }
       }
       collection[prop] = value;
-      stylesObj[prop] = value;
+      (stylesObj as any /** TODO #9100 */)[prop] = value;
     });
     return stylesObj;
   });
 }
 
 export function renderStyles(element: any, renderer: any, styles: {[key: string]: string|number}): void {
-  StringMapWrapper.forEach(styles, (value, prop) => {
+  StringMapWrapper.forEach(styles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
     renderer.setElementStyle(element, prop, value);
   });
 }
@@ -110,8 +110,8 @@ export function renderStyles(element: any, renderer: any, styles: {[key: string]
 export function flattenStyles(styles: {[key: string]: string|number}[]) {
   var finalStyles = {};
   styles.forEach(entry => {
-    StringMapWrapper.forEach(entry, (value, prop) => {
-      finalStyles[prop] = value;
+    StringMapWrapper.forEach(entry, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
+      (finalStyles as any /** TODO #9100 */)[prop] = value;
     });
   });
   return finalStyles;
diff --git a/modules/@angular/core/src/animation/metadata.ts b/modules/@angular/core/src/animation/metadata.ts
index a1148cc4e7..404be1a8f3 100644
--- a/modules/@angular/core/src/animation/metadata.ts
+++ b/modules/@angular/core/src/animation/metadata.ts
@@ -263,7 +263,7 @@ export function style(tokens: string|{[key: string]: string | number}|Array<stri
       input = [<{[key: string]: string | number}>tokens];
     }
     input.forEach(entry => {
-      var entryOffset = entry['offset'];
+      var entryOffset = (entry as any /** TODO #9100 */)['offset'];
       if (isPresent(entryOffset)) {
         offset = offset == null ? NumberWrapper.parseFloat(entryOffset) : offset;
       }
diff --git a/modules/@angular/core/src/application_ref.ts b/modules/@angular/core/src/application_ref.ts
index 7969a31164..824af64a02 100644
--- a/modules/@angular/core/src/application_ref.ts
+++ b/modules/@angular/core/src/application_ref.ts
@@ -283,8 +283,8 @@ export class ApplicationRef_ extends ApplicationRef {
     zone.run(() => { this._exceptionHandler = _injector.get(ExceptionHandler); });
     this._asyncInitDonePromise = this.run(() => {
       let inits: Function[] = _injector.get(APP_INITIALIZER, null);
-      var asyncInitResults = [];
-      var asyncInitDonePromise;
+      var asyncInitResults: any[] /** TODO #9100 */ = [];
+      var asyncInitDonePromise: any /** TODO #9100 */;
       if (isPresent(inits)) {
         for (var i = 0; i < inits.length; i++) {
           var initResult = inits[i]();
@@ -328,7 +328,7 @@ export class ApplicationRef_ extends ApplicationRef {
 
   run(callback: Function): any {
     var zone = this.injector.get(NgZone);
-    var result;
+    var result: any /** TODO #9100 */;
     // Note: Don't use zone.runGuarded as we want to know about
     // the thrown exception!
     // Note: the completer needs to be created outside
@@ -435,7 +435,7 @@ export const PLATFORM_CORE_PROVIDERS =
     ];
 
 export const APPLICATION_CORE_PROVIDERS = /*@ts2dart_const*/[
-  /* @ts2dart_Provider */ {provide: NgZone, useFactory: createNgZone, deps: []},
+  /* @ts2dart_Provider */ {provide: NgZone, useFactory: createNgZone, deps: [] as any},
   ApplicationRef_,
   /* @ts2dart_Provider */ {provide: ApplicationRef, useExisting: ApplicationRef_}
 ];
diff --git a/modules/@angular/core/src/application_tokens.ts b/modules/@angular/core/src/application_tokens.ts
index 1964562976..f8d1a01b28 100644
--- a/modules/@angular/core/src/application_tokens.ts
+++ b/modules/@angular/core/src/application_tokens.ts
@@ -25,7 +25,7 @@ export const APP_ID_RANDOM_PROVIDER =
     /*@ts2dart_const*/ /* @ts2dart_Provider */ {
       provide: APP_ID,
       useFactory: _appIdRandomProviderFactory,
-      deps: []
+      deps: [] as any
     };
 
 function _randomChar(): string {
diff --git a/modules/@angular/core/src/change_detection/differs/default_iterable_differ.ts b/modules/@angular/core/src/change_detection/differs/default_iterable_differ.ts
index b1d068fb8b..c13e6b4a0e 100644
--- a/modules/@angular/core/src/change_detection/differs/default_iterable_differ.ts
+++ b/modules/@angular/core/src/change_detection/differs/default_iterable_differ.ts
@@ -29,7 +29,7 @@ var trackByIdentity = (index: number, item: any) => item;
  */
 export class DefaultIterableDiffer implements IterableDiffer {
   private _length: number = null;
-  private _collection = null;
+  private _collection: any /** TODO #9100 */ = null;
   // Keeps track of the used records at any point in time (during & across `_check()` calls)
   private _linkedRecords: _DuplicateMap = null;
   // Keeps track of the removed records at any point in time during `_check()` calls.
@@ -119,8 +119,8 @@ export class DefaultIterableDiffer implements IterableDiffer {
     var record: CollectionChangeRecord = this._itHead;
     var mayBeDirty: boolean = false;
     var index: number;
-    var item;
-    var itemTrackBy;
+    var item: any /** TODO #9100 */;
+    var itemTrackBy: any /** TODO #9100 */;
     if (isArray(collection)) {
       var list = collection;
       this._length = collection.length;
@@ -143,7 +143,7 @@ export class DefaultIterableDiffer implements IterableDiffer {
       }
     } else {
       index = 0;
-      iterateListLike(collection, (item) => {
+      iterateListLike(collection, (item: any /** TODO #9100 */) => {
         itemTrackBy = this._trackByFn(index, item);
         if (record === null || !looseIdentical(record.trackById, itemTrackBy)) {
           record = this._mismatch(record, item, itemTrackBy, index);
@@ -510,23 +510,23 @@ export class DefaultIterableDiffer implements IterableDiffer {
 
 
   toString(): string {
-    var list = [];
-    this.forEachItem((record) => list.push(record));
+    var list: any[] /** TODO #9100 */ = [];
+    this.forEachItem((record: any /** TODO #9100 */) => list.push(record));
 
-    var previous = [];
-    this.forEachPreviousItem((record) => previous.push(record));
+    var previous: any[] /** TODO #9100 */ = [];
+    this.forEachPreviousItem((record: any /** TODO #9100 */) => previous.push(record));
 
-    var additions = [];
-    this.forEachAddedItem((record) => additions.push(record));
+    var additions: any[] /** TODO #9100 */ = [];
+    this.forEachAddedItem((record: any /** TODO #9100 */) => additions.push(record));
 
-    var moves = [];
-    this.forEachMovedItem((record) => moves.push(record));
+    var moves: any[] /** TODO #9100 */ = [];
+    this.forEachMovedItem((record: any /** TODO #9100 */) => moves.push(record));
 
-    var removals = [];
-    this.forEachRemovedItem((record) => removals.push(record));
+    var removals: any[] /** TODO #9100 */ = [];
+    this.forEachRemovedItem((record: any /** TODO #9100 */) => removals.push(record));
 
-    var identityChanges = [];
-    this.forEachIdentityChange((record) => identityChanges.push(record));
+    var identityChanges: any[] /** TODO #9100 */ = [];
+    this.forEachIdentityChange((record: any /** TODO #9100 */) => identityChanges.push(record));
 
     return "collection: " + list.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" +
            "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" +
diff --git a/modules/@angular/core/src/change_detection/differs/default_keyvalue_differ.ts b/modules/@angular/core/src/change_detection/differs/default_keyvalue_differ.ts
index bd8611a41e..7f7cb217f1 100644
--- a/modules/@angular/core/src/change_detection/differs/default_keyvalue_differ.ts
+++ b/modules/@angular/core/src/change_detection/differs/default_keyvalue_differ.ts
@@ -86,8 +86,8 @@ export class DefaultKeyValueDiffer implements KeyValueDiffer {
     var lastNewSeqRecord: KeyValueChangeRecord = null;
     var seqChanged: boolean = false;
 
-    this._forEach(map, (value, key) => {
-      var newSeqRecord;
+    this._forEach(map, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => {
+      var newSeqRecord: any /** TODO #9100 */;
       if (oldSeqRecord !== null && key === oldSeqRecord.key) {
         newSeqRecord = oldSeqRecord;
         if (!looseIdentical(value, oldSeqRecord.currentValue)) {
@@ -296,11 +296,11 @@ export class DefaultKeyValueDiffer implements KeyValueDiffer {
   }
 
   toString(): string {
-    var items = [];
-    var previous = [];
-    var changes = [];
-    var additions = [];
-    var removals = [];
+    var items: any[] /** TODO #9100 */ = [];
+    var previous: any[] /** TODO #9100 */ = [];
+    var changes: any[] /** TODO #9100 */ = [];
+    var additions: any[] /** TODO #9100 */ = [];
+    var removals: any[] /** TODO #9100 */ = [];
     var record: KeyValueChangeRecord;
 
     for (record = this._mapHead; record !== null; record = record._next) {
@@ -325,7 +325,7 @@ export class DefaultKeyValueDiffer implements KeyValueDiffer {
   }
 
   /** @internal */
-  _forEach(obj, fn: Function) {
+  _forEach(obj: any /** TODO #9100 */, fn: Function) {
     if (obj instanceof Map) {
       (<Map<any, any>>obj).forEach(<any>fn);
     } else {
diff --git a/modules/@angular/core/src/change_detection/differs/iterable_differs.ts b/modules/@angular/core/src/change_detection/differs/iterable_differs.ts
index b820164dec..7f946a55c9 100644
--- a/modules/@angular/core/src/change_detection/differs/iterable_differs.ts
+++ b/modules/@angular/core/src/change_detection/differs/iterable_differs.ts
@@ -12,7 +12,7 @@ import {Provider, SkipSelfMetadata, OptionalMetadata} from '../../di';
  */
 export interface IterableDiffer {
   diff(object: any): any;
-  onDestroy();
+  onDestroy(): any /** TODO #9100 */;
 }
 
 /**
diff --git a/modules/@angular/core/src/change_detection/differs/keyvalue_differs.ts b/modules/@angular/core/src/change_detection/differs/keyvalue_differs.ts
index bd16c3027d..312328c6f2 100644
--- a/modules/@angular/core/src/change_detection/differs/keyvalue_differs.ts
+++ b/modules/@angular/core/src/change_detection/differs/keyvalue_differs.ts
@@ -8,8 +8,8 @@ import {Provider, SkipSelfMetadata, OptionalMetadata} from '../../di';
  * A differ that tracks changes made to an object over time.
  */
 export interface KeyValueDiffer {
-  diff(object: any);
-  onDestroy();
+  diff(object: any): any /** TODO #9100 */;
+  onDestroy(): any /** TODO #9100 */;
 }
 
 /**
diff --git a/modules/@angular/core/src/di/metadata.ts b/modules/@angular/core/src/di/metadata.ts
index 38e2154afb..5dad0d20a4 100644
--- a/modules/@angular/core/src/di/metadata.ts
+++ b/modules/@angular/core/src/di/metadata.ts
@@ -43,7 +43,7 @@ import {stringify} from '../facade/lang';
  * @stable
  */
 export class InjectMetadata {
-  constructor(public token) {}
+  constructor(public token: any /** TODO #9100 */) {}
   toString(): string { return `@Inject(${stringify(this.token)})`; }
 }
 
@@ -81,7 +81,7 @@ export class OptionalMetadata {
  * @stable
  */
 export class DependencyMetadata {
-  get token() { return null; }
+  get token(): any /** TODO #9100 */ { return null; }
 }
 
 /**
diff --git a/modules/@angular/core/src/di/provider.ts b/modules/@angular/core/src/di/provider.ts
index 174f49fdb5..9c9332fe92 100644
--- a/modules/@angular/core/src/di/provider.ts
+++ b/modules/@angular/core/src/di/provider.ts
@@ -22,7 +22,7 @@ export class Provider {
   /**
    * Token used when retrieving this provider. Usually, it is a type {@link Type}.
    */
-  token;
+  token: any /** TODO #9100 */;
 
   /**
    * Binds a DI token to an implementation class.
@@ -68,7 +68,7 @@ export class Provider {
    * expect(injector.get("message")).toEqual('Hello');
    * ```
    */
-  useValue;
+  useValue: any /** TODO #9100 */;
 
   /**
    * Binds a DI token to an existing token.
@@ -102,7 +102,7 @@ export class Provider {
    * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
    * ```
    */
-  useExisting;
+  useExisting: any /** TODO #9100 */;
 
   /**
    * Binds a DI token to a function which computes the value.
@@ -148,7 +148,7 @@ export class Provider {
   /** @internal */
   _multi: boolean;
 
-  constructor(token, {useClass, useValue, useExisting, useFactory, deps, multi}: {
+  constructor(token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
     useClass?: Type,
     useValue?: any,
     useExisting?: any,
@@ -205,7 +205,7 @@ export class Provider {
  * @ts2dart_const
  */
 export class Binding extends Provider {
-  constructor(token, {toClass, toValue, toAlias, toFactory, deps, multi}: {
+  constructor(token: any /** TODO #9100 */, {toClass, toValue, toAlias, toFactory, deps, multi}: {
     toClass?: Type,
     toValue?: any,
     toAlias?: any,
@@ -254,7 +254,7 @@ export class Binding extends Provider {
  *
  * @deprecated
  */
-export function bind(token): ProviderBuilder {
+export function bind(token: any /** TODO #9100 */): ProviderBuilder {
   return new ProviderBuilder(token);
 }
 
@@ -263,7 +263,7 @@ export function bind(token): ProviderBuilder {
  * @deprecated
  */
 export class ProviderBuilder {
-  constructor(public token) {}
+  constructor(public token: any /** TODO #9100 */) {}
 
   /**
    * Binds a DI token to a class.
@@ -388,7 +388,7 @@ export class ProviderBuilder {
  * <!-- TODO: improve the docs -->
  * @deprecated
  */
-export function provide(token, {useClass, useValue, useExisting, useFactory, deps, multi}: {
+export function provide(token: any /** TODO #9100 */, {useClass, useValue, useExisting, useFactory, deps, multi}: {
   useClass?: Type,
   useValue?: any,
   useExisting?: any,
diff --git a/modules/@angular/core/src/di/reflective_exceptions.ts b/modules/@angular/core/src/di/reflective_exceptions.ts
index 587fc6c04a..b6fa4a7158 100644
--- a/modules/@angular/core/src/di/reflective_exceptions.ts
+++ b/modules/@angular/core/src/di/reflective_exceptions.ts
@@ -5,7 +5,7 @@ import {ReflectiveKey} from './reflective_key';
 import {ReflectiveInjector} from './reflective_injector';
 
 function findFirstClosedCycle(keys: any[]): any[] {
-  var res = [];
+  var res: any[] /** TODO #9100 */ = [];
   for (var i = 0; i < keys.length; ++i) {
     if (ListWrapper.contains(res, keys[i])) {
       res.push(keys[i]);
@@ -146,7 +146,7 @@ export class InstantiationError extends WrappedException {
   /** @internal */
   injectors: ReflectiveInjector[];
 
-  constructor(injector: ReflectiveInjector, originalException, originalStack, key: ReflectiveKey) {
+  constructor(injector: ReflectiveInjector, originalException: any /** TODO #9100 */, originalStack: any /** TODO #9100 */, key: ReflectiveKey) {
     super("DI Exception", originalException, originalStack, null);
     this.keys = [key];
     this.injectors = [injector];
@@ -179,7 +179,7 @@ export class InstantiationError extends WrappedException {
  * @stable
  */
 export class InvalidProviderError extends BaseException {
-  constructor(provider) {
+  constructor(provider: any /** TODO #9100 */) {
     super(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
   }
 }
@@ -214,12 +214,12 @@ export class InvalidProviderError extends BaseException {
  * @stable
  */
 export class NoAnnotationError extends BaseException {
-  constructor(typeOrFunc, params: any[][]) {
+  constructor(typeOrFunc: any /** TODO #9100 */, params: any[][]) {
     super(NoAnnotationError._genMessage(typeOrFunc, params));
   }
 
-  private static _genMessage(typeOrFunc, params: any[][]) {
-    var signature = [];
+  private static _genMessage(typeOrFunc: any /** TODO #9100 */, params: any[][]) {
+    var signature: any[] /** TODO #9100 */ = [];
     for (var i = 0, ii = params.length; i < ii; i++) {
       var parameter = params[i];
       if (isBlank(parameter) || parameter.length == 0) {
@@ -250,7 +250,7 @@ export class NoAnnotationError extends BaseException {
  * @stable
  */
 export class OutOfBoundsError extends BaseException {
-  constructor(index) { super(`Index ${index} is out-of-bounds.`); }
+  constructor(index: any /** TODO #9100 */) { super(`Index ${index} is out-of-bounds.`); }
 }
 
 // TODO: add a working example after alpha38 is released
@@ -267,7 +267,7 @@ export class OutOfBoundsError extends BaseException {
  * ```
  */
 export class MixingMultiProvidersWithRegularProvidersError extends BaseException {
-  constructor(provider1, provider2) {
+  constructor(provider1: any /** TODO #9100 */, provider2: any /** TODO #9100 */) {
     super("Cannot mix multi providers and regular providers, got: " + provider1.toString() + " " +
           provider2.toString());
   }
diff --git a/modules/@angular/core/src/di/reflective_injector.ts b/modules/@angular/core/src/di/reflective_injector.ts
index f46fa74bd4..7521ee6766 100644
--- a/modules/@angular/core/src/di/reflective_injector.ts
+++ b/modules/@angular/core/src/di/reflective_injector.ts
@@ -734,7 +734,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
       throw e;
     }
 
-    var obj;
+    var obj: any /** TODO #9100 */;
     try {
       switch (length) {
         case 0:
@@ -881,7 +881,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
 var INJECTOR_KEY = ReflectiveKey.get(Injector);
 
 function _mapProviders(injector: ReflectiveInjector_, fn: Function): any[] {
-  var res = [];
+  var res: any[] /** TODO #9100 */ = [];
   for (var i = 0; i < injector._proto.numberOfProviders; ++i) {
     res.push(fn(injector._proto.getProviderAtIndex(i)));
   }
diff --git a/modules/@angular/core/src/di/reflective_provider.ts b/modules/@angular/core/src/di/reflective_provider.ts
index 2b39acc5b9..04823935d0 100644
--- a/modules/@angular/core/src/di/reflective_provider.ts
+++ b/modules/@angular/core/src/di/reflective_provider.ts
@@ -37,7 +37,7 @@ export class ReflectiveDependency {
   }
 }
 
-const _EMPTY_LIST = /*@ts2dart_const*/[];
+const _EMPTY_LIST: any[] /** TODO #9100 */ = /*@ts2dart_const*/[];
 
 /**
  * An internal resolved representation of a {@link Provider} used by the {@link Injector}.
@@ -109,13 +109,13 @@ export class ResolvedReflectiveFactory {
  */
 export function resolveReflectiveFactory(provider: Provider): ResolvedReflectiveFactory {
   var factoryFn: Function;
-  var resolvedDeps;
+  var resolvedDeps: any /** TODO #9100 */;
   if (isPresent(provider.useClass)) {
     var useClass = resolveForwardRef(provider.useClass);
     factoryFn = reflector.factory(useClass);
     resolvedDeps = _dependenciesFor(useClass);
   } else if (isPresent(provider.useExisting)) {
-    factoryFn = (aliasInstance) => aliasInstance;
+    factoryFn = (aliasInstance: any /** TODO #9100 */) => aliasInstance;
     resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
   } else if (isPresent(provider.useFactory)) {
     factoryFn = provider.useFactory;
@@ -173,7 +173,7 @@ export function mergeResolvedReflectiveProviders(
         normalizedProvidersMap.set(provider.key.id, provider);
       }
     } else {
-      var resolvedProvider;
+      var resolvedProvider: any /** TODO #9100 */;
       if (provider.multiProvider) {
         resolvedProvider = new ResolvedReflectiveProvider_(
             provider.key, ListWrapper.clone(provider.resolvedFactories), provider.multiProvider);
@@ -232,10 +232,10 @@ function _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {
   return params.map((p: any[]) => _extractToken(typeOrFunc, p, params));
 }
 
-function _extractToken(typeOrFunc, metadata /*any[] | any*/,
+function _extractToken(typeOrFunc: any /** TODO #9100 */, metadata: any /** TODO #9100 */ /*any[] | any*/,
                        params: any[][]): ReflectiveDependency {
-  var depProps = [];
-  var token = null;
+  var depProps: any[] /** TODO #9100 */ = [];
+  var token: any /** TODO #9100 */ = null;
   var optional = false;
 
   if (!isArray(metadata)) {
@@ -246,8 +246,8 @@ function _extractToken(typeOrFunc, metadata /*any[] | any*/,
     }
   }
 
-  var lowerBoundVisibility = null;
-  var upperBoundVisibility = null;
+  var lowerBoundVisibility: any /** TODO #9100 */ = null;
+  var upperBoundVisibility: any /** TODO #9100 */ = null;
 
   for (var i = 0; i < metadata.length; ++i) {
     var paramMetadata = metadata[i];
@@ -287,8 +287,8 @@ function _extractToken(typeOrFunc, metadata /*any[] | any*/,
   }
 }
 
-function _createDependency(token, optional, lowerBoundVisibility, upperBoundVisibility,
-                           depProps): ReflectiveDependency {
+function _createDependency(token: any /** TODO #9100 */, optional: any /** TODO #9100 */, lowerBoundVisibility: any /** TODO #9100 */, upperBoundVisibility: any /** TODO #9100 */,
+                           depProps: any /** TODO #9100 */): ReflectiveDependency {
   return new ReflectiveDependency(ReflectiveKey.get(token), optional, lowerBoundVisibility,
                                   upperBoundVisibility, depProps);
 }
diff --git a/modules/@angular/core/src/linker/component_resolver.ts b/modules/@angular/core/src/linker/component_resolver.ts
index 8f942d3619..970f3cd822 100644
--- a/modules/@angular/core/src/linker/component_resolver.ts
+++ b/modules/@angular/core/src/linker/component_resolver.ts
@@ -12,7 +12,7 @@ import {Injectable} from '../di/decorators';
  */
 export abstract class ComponentResolver {
   abstract resolveComponent(component: Type|string): Promise<ComponentFactory<any>>;
-  abstract clearCache();
+  abstract clearCache(): any /** TODO #9100 */;
 }
 
 function _isComponentFactory(type: any): boolean {
diff --git a/modules/@angular/core/src/linker/debug_context.ts b/modules/@angular/core/src/linker/debug_context.ts
index 2d2432b310..762953ae37 100644
--- a/modules/@angular/core/src/linker/debug_context.ts
+++ b/modules/@angular/core/src/linker/debug_context.ts
@@ -57,8 +57,8 @@ export class DebugContext implements RenderDebugInfo {
     var staticNodeInfo = this._staticNodeInfo;
     if (isPresent(staticNodeInfo)) {
       var refs = staticNodeInfo.refTokens;
-      StringMapWrapper.forEach(refs, (refToken, refName) => {
-        var varValue;
+      StringMapWrapper.forEach(refs, (refToken: any /** TODO #9100 */, refName: any /** TODO #9100 */) => {
+        var varValue: any /** TODO #9100 */;
         if (isBlank(refToken)) {
           varValue = isPresent(this._view.allNodes) ? this._view.allNodes[this._nodeIndex] : null;
         } else {
diff --git a/modules/@angular/core/src/linker/element.ts b/modules/@angular/core/src/linker/element.ts
index c40ce93ed0..48a8b2371d 100644
--- a/modules/@angular/core/src/linker/element.ts
+++ b/modules/@angular/core/src/linker/element.ts
@@ -41,7 +41,7 @@ export class AppElement {
   get injector(): Injector { return this.parentView.injector(this.index); }
 
   mapNestedViews(nestedViewClass: any, callback: Function): any[] {
-    var result = [];
+    var result: any[] /** TODO #9100 */ = [];
     if (isPresent(this.nestedViews)) {
       this.nestedViews.forEach((nestedView) => {
         if (nestedView.clazz === nestedViewClass) {
@@ -63,7 +63,7 @@ export class AppElement {
       this.nestedViews = nestedViews;
     }
     ListWrapper.insert(nestedViews, viewIndex, view);
-    var refRenderNode;
+    var refRenderNode: any /** TODO #9100 */;
     if (viewIndex > 0) {
       var prevView = nestedViews[viewIndex - 1];
       refRenderNode = prevView.lastRootNode;
diff --git a/modules/@angular/core/src/linker/query_list.ts b/modules/@angular/core/src/linker/query_list.ts
index b0d0f55721..ed9dff16c2 100644
--- a/modules/@angular/core/src/linker/query_list.ts
+++ b/modules/@angular/core/src/linker/query_list.ts
@@ -61,7 +61,7 @@ export class QueryList<T> {
    */
   toArray(): T[] { return ListWrapper.clone(this._results); }
 
-  [getSymbolIterator()](): any { return this._results[getSymbolIterator()](); }
+  [getSymbolIterator()](): any { return (this._results as any /** TODO #???? */)[getSymbolIterator()](); }
 
   toString(): string { return this._results.toString(); }
 
diff --git a/modules/@angular/core/src/linker/systemjs_component_resolver.ts b/modules/@angular/core/src/linker/systemjs_component_resolver.ts
index fb9c0a0d74..4bfa9fee8d 100644
--- a/modules/@angular/core/src/linker/systemjs_component_resolver.ts
+++ b/modules/@angular/core/src/linker/systemjs_component_resolver.ts
@@ -11,7 +11,7 @@ export class SystemJsComponentResolver implements ComponentResolver {
 
   resolveComponent(componentType:string|Type):Promise<ComponentFactory<any>> {
     if (isString(componentType)) {
-      return (<any>global).System.import(componentType).then(module =>
+      return (<any>global).System.import(componentType).then((module: any /** TODO #9100 */) =>
         this._resolver.resolveComponent(module.default));
     } else {
       return this._resolver.resolveComponent(<Type>componentType);
diff --git a/modules/@angular/core/src/linker/view.ts b/modules/@angular/core/src/linker/view.ts
index 50385247c1..bd9008d3da 100644
--- a/modules/@angular/core/src/linker/view.ts
+++ b/modules/@angular/core/src/linker/view.ts
@@ -118,7 +118,7 @@ export abstract class AppView<T> {
   create(context: T, givenProjectableNodes: Array<any | any[]>,
          rootSelectorOrNode: string | any): AppElement {
     this.context = context;
-    var projectableNodes;
+    var projectableNodes: any /** TODO #9100 */;
     switch (this.type) {
       case ViewType.COMPONENT:
         projectableNodes = ensureSlotCount(givenProjectableNodes, this.componentType.slotCount);
@@ -159,7 +159,7 @@ export abstract class AppView<T> {
 
   selectOrCreateHostElement(elementName: string, rootSelectorOrNode: string | any,
                             debugInfo: RenderDebugInfo): any {
-    var hostElement;
+    var hostElement: any /** TODO #9100 */;
     if (isPresent(rootSelectorOrNode)) {
       hostElement = this.renderer.selectRootElement(rootSelectorOrNode, debugInfo);
     } else {
@@ -427,7 +427,7 @@ export class DebugAppView<T> extends AppView<T> {
 
   eventHandler(cb: Function): Function {
     var superHandler = super.eventHandler(cb);
-    return (event) => {
+    return (event: any /** TODO #9100 */) => {
       this._resetDebug();
       try {
         return superHandler(event);
@@ -440,7 +440,7 @@ export class DebugAppView<T> extends AppView<T> {
 }
 
 function _findLastRenderNode(node: any): any {
-  var lastNode;
+  var lastNode: any /** TODO #9100 */;
   if (node instanceof AppElement) {
     var appEl = <AppElement>node;
     lastNode = appEl.nativeElement;
diff --git a/modules/@angular/core/src/linker/view_ref.ts b/modules/@angular/core/src/linker/view_ref.ts
index 2412d3ec24..6cce179130 100644
--- a/modules/@angular/core/src/linker/view_ref.ts
+++ b/modules/@angular/core/src/linker/view_ref.ts
@@ -9,7 +9,7 @@ import {ChangeDetectionStrategy} from '../change_detection/constants';
 export abstract class ViewRef {
   get destroyed(): boolean { return <boolean>unimplemented(); }
 
-  abstract onDestroy(callback: Function);
+  abstract onDestroy(callback: Function): any /** TODO #9100 */;
 }
 
 /**
@@ -74,7 +74,7 @@ export abstract class EmbeddedViewRef<C> extends ViewRef {
   /**
    * Destroys the view and all of the data structures associated with it.
    */
-  abstract destroy();
+  abstract destroy(): any /** TODO #9100 */;
 }
 
 export class ViewRef_<C> implements EmbeddedViewRef<C>, ChangeDetectorRef {
diff --git a/modules/@angular/core/src/linker/view_utils.ts b/modules/@angular/core/src/linker/view_utils.ts
index d2643a6507..df1314f4a8 100644
--- a/modules/@angular/core/src/linker/view_utils.ts
+++ b/modules/@angular/core/src/linker/view_utils.ts
@@ -59,10 +59,10 @@ function _flattenNestedViewRenderNodes(nodes: any[], renderNodes: any[]): any[]
   return renderNodes;
 }
 
-const EMPTY_ARR = /*@ts2dart_const*/[];
+const EMPTY_ARR: any[] /** TODO #9100 */ = /*@ts2dart_const*/[];
 
 export function ensureSlotCount(projectableNodes: any[][], expectedSlotCount: number): any[][] {
-  var res;
+  var res: any /** TODO #9100 */;
   if (isBlank(projectableNodes)) {
     res = EMPTY_ARR;
   } else if (projectableNodes.length < expectedSlotCount) {
@@ -148,7 +148,7 @@ export function mapLooseIdentical<V>(m1: {[key: string]: V}, m2: {[key: string]:
   if (k1.length != k2.length) {
     return false;
   }
-  var key;
+  var key: any /** TODO #9100 */;
   for (var i = 0; i < k1.length; i++) {
     key = k1[i];
     if (!looseIdentical(m1[key], m2[key])) {
@@ -162,12 +162,12 @@ export function castByValue<T>(input: any, value: T): T {
   return <T>input;
 }
 
-export const EMPTY_ARRAY = /*@ts2dart_const*/[];
+export const EMPTY_ARRAY: any[] /** TODO #9100 */ = /*@ts2dart_const*/[];
 export const EMPTY_MAP = /*@ts2dart_const*/ {};
 
 export function pureProxy1<P0, R>(fn: (p0: P0) => R): (p0: P0) => R {
   var result: R;
-  var v0;
+  var v0: any /** TODO #9100 */;
   v0 = uninitialized;
   return (p0) => {
     if (!looseIdentical(v0, p0)) {
@@ -180,7 +180,7 @@ export function pureProxy1<P0, R>(fn: (p0: P0) => R): (p0: P0) => R {
 
 export function pureProxy2<P0, P1, R>(fn: (p0: P0, p1: P1) => R): (p0: P0, p1: P1) => R {
   var result: R;
-  var v0, v1;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */;
   v0 = v1 = uninitialized;
   return (p0, p1) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1)) {
@@ -195,7 +195,7 @@ export function pureProxy2<P0, P1, R>(fn: (p0: P0, p1: P1) => R): (p0: P0, p1: P
 export function pureProxy3<P0, P1, P2, R>(fn: (p0: P0, p1: P1, p2: P2) => R): (p0: P0, p1: P1,
                                                                                p2: P2) => R {
   var result: R;
-  var v0, v1, v2;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */;
   v0 = v1 = v2 = uninitialized;
   return (p0, p1, p2) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2)) {
@@ -211,7 +211,7 @@ export function pureProxy3<P0, P1, P2, R>(fn: (p0: P0, p1: P1, p2: P2) => R): (p
 export function pureProxy4<P0, P1, P2, P3, R>(fn: (p0: P0, p1: P1, p2: P2, p3: P3) => R): (
     p0: P0, p1: P1, p2: P2, p3: P3) => R {
   var result: R;
-  var v0, v1, v2, v3;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = uninitialized;
   return (p0, p1, p2, p3) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -230,7 +230,7 @@ export function pureProxy5<P0, P1, P2, P3, P4, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) => R): (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) =>
     R {
   var result: R;
-  var v0, v1, v2, v3, v4;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = uninitialized;
   return (p0, p1, p2, p3, p4) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -251,7 +251,7 @@ export function pureProxy6<P0, P1, P2, P3, P4, P5, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p0: P0, p1: P1, p2: P2, p3: P3,
                                                                  p4: P4, p5: P5) => R {
   var result: R;
-  var v0, v1, v2, v3, v4, v5;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */, v5: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = v5 = uninitialized;
   return (p0, p1, p2, p3, p4, p5) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -272,7 +272,7 @@ export function pureProxy7<P0, P1, P2, P3, P4, P5, P6, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) =>
         R): (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) => R {
   var result: R;
-  var v0, v1, v2, v3, v4, v5, v6;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */, v5: any /** TODO #9100 */, v6: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = v5 = v6 = uninitialized;
   return (p0, p1, p2, p3, p4, p5, p6) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -295,7 +295,7 @@ export function pureProxy8<P0, P1, P2, P3, P4, P5, P6, P7, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) =>
         R): (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) => R {
   var result: R;
-  var v0, v1, v2, v3, v4, v5, v6, v7;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */, v5: any /** TODO #9100 */, v6: any /** TODO #9100 */, v7: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = uninitialized;
   return (p0, p1, p2, p3, p4, p5, p6, p7) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -319,7 +319,7 @@ export function pureProxy9<P0, P1, P2, P3, P4, P5, P6, P7, P8, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8) =>
         R): (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8) => R {
   var result: R;
-  var v0, v1, v2, v3, v4, v5, v6, v7, v8;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */, v5: any /** TODO #9100 */, v6: any /** TODO #9100 */, v7: any /** TODO #9100 */, v8: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = uninitialized;
   return (p0, p1, p2, p3, p4, p5, p6, p7, p8) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
@@ -344,7 +344,7 @@ export function pureProxy10<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(
     fn: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9) =>
         R): (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9) => R {
   var result: R;
-  var v0, v1, v2, v3, v4, v5, v6, v7, v8, v9;
+  var v0: any /** TODO #9100 */, v1: any /** TODO #9100 */, v2: any /** TODO #9100 */, v3: any /** TODO #9100 */, v4: any /** TODO #9100 */, v5: any /** TODO #9100 */, v6: any /** TODO #9100 */, v7: any /** TODO #9100 */, v8: any /** TODO #9100 */, v9: any /** TODO #9100 */;
   v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = v8 = v9 = uninitialized;
   return (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) => {
     if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) ||
diff --git a/modules/@angular/core/src/metadata/lifecycle_hooks.ts b/modules/@angular/core/src/metadata/lifecycle_hooks.ts
index 885dead94c..5d61f306d0 100644
--- a/modules/@angular/core/src/metadata/lifecycle_hooks.ts
+++ b/modules/@angular/core/src/metadata/lifecycle_hooks.ts
@@ -83,7 +83,7 @@ export var LIFECYCLE_HOOKS_VALUES = [
  * ```
  * @stable
  */
-export abstract class OnChanges { abstract ngOnChanges(changes: SimpleChanges); }
+export abstract class OnChanges { abstract ngOnChanges(changes: SimpleChanges): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to execute custom initialization logic after your directive's
@@ -127,7 +127,7 @@ export abstract class OnChanges { abstract ngOnChanges(changes: SimpleChanges);
  *  ```
  * @stable
  */
-export abstract class OnInit { abstract ngOnInit(); }
+export abstract class OnInit { abstract ngOnInit(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to supplement the default change detection algorithm in your directive.
@@ -192,7 +192,7 @@ export abstract class OnInit { abstract ngOnInit(); }
  * ```
  * @stable
  */
-export abstract class DoCheck { abstract ngDoCheck(); }
+export abstract class DoCheck { abstract ngDoCheck(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to get notified when your directive is destroyed.
@@ -284,7 +284,7 @@ export abstract class DoCheck { abstract ngDoCheck(); }
  *
  * @stable
  */
-export abstract class OnDestroy { abstract ngOnDestroy(); }
+export abstract class OnDestroy { abstract ngOnDestroy(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to get notified when your directive's content has been fully
@@ -338,7 +338,7 @@ export abstract class OnDestroy { abstract ngOnDestroy(); }
  * ```
  * @stable
  */
-export abstract class AfterContentInit { abstract ngAfterContentInit(); }
+export abstract class AfterContentInit { abstract ngAfterContentInit(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to get notified after every check of your directive's content.
@@ -387,7 +387,7 @@ export abstract class AfterContentInit { abstract ngAfterContentInit(); }
  * ```
  * @stable
  */
-export abstract class AfterContentChecked { abstract ngAfterContentChecked(); }
+export abstract class AfterContentChecked { abstract ngAfterContentChecked(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to get notified when your component's view has been fully initialized.
@@ -435,7 +435,7 @@ export abstract class AfterContentChecked { abstract ngAfterContentChecked(); }
  * ```
  * @stable
  */
-export abstract class AfterViewInit { abstract ngAfterViewInit(); }
+export abstract class AfterViewInit { abstract ngAfterViewInit(): any /** TODO #9100 */; }
 
 /**
  * Implement this interface to get notified after every check of your component's view.
@@ -486,4 +486,4 @@ export abstract class AfterViewInit { abstract ngAfterViewInit(); }
  * ```
  * @stable
  */
-export abstract class AfterViewChecked { abstract ngAfterViewChecked(); }
+export abstract class AfterViewChecked { abstract ngAfterViewChecked(): any /** TODO #9100 */; }
diff --git a/modules/@angular/core/src/profile/wtf_impl.ts b/modules/@angular/core/src/profile/wtf_impl.ts
index 35d21b8c8c..1c6d90f63a 100644
--- a/modules/@angular/core/src/profile/wtf_impl.ts
+++ b/modules/@angular/core/src/profile/wtf_impl.ts
@@ -11,9 +11,9 @@ interface WTF {
 
 interface Trace {
   events: Events;
-  leaveScope(scope: Scope, returnValue: any);
+  leaveScope(scope: Scope, returnValue: any): any /** TODO #9100 */;
   beginTimeRange(rangeType: string, action: string): Range;
-  endTimeRange(range: Range);
+  endTimeRange(range: Range): any /** TODO #9100 */;
 }
 
 export interface Range {}
@@ -22,13 +22,13 @@ interface Events {
   createScope(signature: string, flags: any): Scope;
 }
 
-export interface Scope { (...args): any; }
+export interface Scope { (...args: any[] /** TODO #9100 */): any; }
 
 var trace: Trace;
 var events: Events;
 
 export function detectWTF(): boolean {
-  var wtf: WTF = global['wtf'];
+  var wtf: WTF = (global as any /** TODO #9100 */)['wtf'];
   if (wtf) {
     trace = wtf['trace'];
     if (trace) {
diff --git a/modules/@angular/core/src/reflection/reflection_capabilities.ts b/modules/@angular/core/src/reflection/reflection_capabilities.ts
index b9314a2950..ff5a4ae9fe 100644
--- a/modules/@angular/core/src/reflection/reflection_capabilities.ts
+++ b/modules/@angular/core/src/reflection/reflection_capabilities.ts
@@ -89,8 +89,8 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
   }
 
   /** @internal */
-  _zipTypesAndAnnotations(paramTypes, paramAnnotations): any[][] {
-    var result;
+  _zipTypesAndAnnotations(paramTypes: any /** TODO #9100 */, paramAnnotations: any /** TODO #9100 */): any[][] {
+    var result: any /** TODO #9100 */;
 
     if (typeof paramTypes === 'undefined') {
       result = new Array(paramAnnotations.length);
@@ -125,9 +125,9 @@ export class ReflectionCapabilities implements PlatformReflectionCapabilities {
     // API of tsickle for lowering decorators to properties on the class.
     if (isPresent((<any>typeOrFunc).ctorParameters)) {
       let ctorParameters = (<any>typeOrFunc).ctorParameters;
-      let paramTypes = ctorParameters.map(ctorParam => ctorParam && ctorParam.type);
+      let paramTypes = ctorParameters.map((ctorParam: any /** TODO #9100 */) => ctorParam && ctorParam.type);
       let paramAnnotations = ctorParameters.map(
-          ctorParam => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
+          (ctorParam: any /** TODO #9100 */) => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
       return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
     }
 
diff --git a/modules/@angular/core/src/render/api.ts b/modules/@angular/core/src/render/api.ts
index 53d11de08b..5c92b6c547 100644
--- a/modules/@angular/core/src/render/api.ts
+++ b/modules/@angular/core/src/render/api.ts
@@ -59,13 +59,13 @@ export abstract class Renderer {
   abstract setBindingDebugInfo(renderElement: any, propertyName: string,
                                propertyValue: string): void;
 
-  abstract setElementClass(renderElement: any, className: string, isAdd: boolean);
+  abstract setElementClass(renderElement: any, className: string, isAdd: boolean): any /** TODO #9100 */;
 
-  abstract setElementStyle(renderElement: any, styleName: string, styleValue: string);
+  abstract setElementStyle(renderElement: any, styleName: string, styleValue: string): any /** TODO #9100 */;
 
-  abstract invokeElementMethod(renderElement: any, methodName: string, args?: any[]);
+  abstract invokeElementMethod(renderElement: any, methodName: string, args?: any[]): any /** TODO #9100 */;
 
-  abstract setText(renderNode: any, text: string);
+  abstract setText(renderNode: any, text: string): any /** TODO #9100 */;
 
   abstract animate(element: any, startingStyles: AnimationStyles, keyframes: AnimationKeyframe[], duration: number, delay: number, easing: string): AnimationPlayer;
 }
diff --git a/modules/@angular/core/src/util/decorators.ts b/modules/@angular/core/src/util/decorators.ts
index 5928fb321c..d26263660f 100644
--- a/modules/@angular/core/src/util/decorators.ts
+++ b/modules/@angular/core/src/util/decorators.ts
@@ -232,7 +232,7 @@ export function Class(clsDef: ClassDefinition): ConcreteType {
   }
 
   if (!constructor['name']) {
-    constructor['overriddenName'] = `class${_nextClassId++}`;
+    (constructor as any /** TODO #9100 */)['overriddenName'] = `class${_nextClassId++}`;
   }
 
   return <ConcreteType>constructor;
@@ -248,8 +248,8 @@ var Reflect = global.Reflect;
 })();
 
 export function makeDecorator(
-    annotationCls, chainFn: (fn: Function) => void = null): (...args: any[]) => (cls: any) => any {
-  function DecoratorFactory(objOrType): (cls: any) => any {
+    annotationCls: any /** TODO #9100 */, chainFn: (fn: Function) => void = null): (...args: any[]) => (cls: any) => any {
+  function DecoratorFactory(objOrType: any /** TODO #9100 */): (cls: any) => any {
     var annotationInstance = new (<any>annotationCls)(objOrType);
     if (this instanceof annotationCls) {
       return annotationInstance;
@@ -257,7 +257,7 @@ export function makeDecorator(
       var chainAnnotation =
           isFunction(this) && this.annotations instanceof Array ? this.annotations : [];
       chainAnnotation.push(annotationInstance);
-      var TypeDecorator: TypeDecorator = <TypeDecorator>function TypeDecorator(cls) {
+      var TypeDecorator: TypeDecorator = <TypeDecorator>function TypeDecorator(cls: any /** TODO #9100 */) {
         var annotations = Reflect.getOwnMetadata('annotations', cls);
         annotations = annotations || [];
         annotations.push(annotationInstance);
@@ -275,8 +275,8 @@ export function makeDecorator(
   return DecoratorFactory;
 }
 
-export function makeParamDecorator(annotationCls): any {
-  function ParamDecoratorFactory(...args): any {
+export function makeParamDecorator(annotationCls: any /** TODO #9100 */): any {
+  function ParamDecoratorFactory(...args: any[] /** TODO #9100 */): any {
     var annotationInstance = Object.create(annotationCls.prototype);
     annotationCls.apply(annotationInstance, args);
     if (this instanceof annotationCls) {
@@ -287,7 +287,7 @@ export function makeParamDecorator(annotationCls): any {
     }
 
 
-    function ParamDecorator(cls, unusedKey, index): any {
+    function ParamDecorator(cls: any /** TODO #9100 */, unusedKey: any /** TODO #9100 */, index: any /** TODO #9100 */): any {
       var parameters: any[][] = Reflect.getMetadata('parameters', cls);
       parameters = parameters || [];
 
@@ -310,8 +310,8 @@ export function makeParamDecorator(annotationCls): any {
   return ParamDecoratorFactory;
 }
 
-export function makePropDecorator(annotationCls): any {
-  function PropDecoratorFactory(...args): any {
+export function makePropDecorator(annotationCls: any /** TODO #9100 */): any {
+  function PropDecoratorFactory(...args: any[] /** TODO #9100 */): any {
     var decoratorInstance = Object.create(annotationCls.prototype);
     annotationCls.apply(decoratorInstance, args);
 
diff --git a/modules/@angular/core/src/zone/ng_zone_impl.ts b/modules/@angular/core/src/zone/ng_zone_impl.ts
index 0a4fc9cb2d..15f1a63aee 100644
--- a/modules/@angular/core/src/zone/ng_zone_impl.ts
+++ b/modules/@angular/core/src/zone/ng_zone_impl.ts
@@ -37,11 +37,11 @@ export class NgZoneImpl {
 
     if (Zone) {
       this.outer = this.inner = Zone.current;
-      if (Zone['wtfZoneSpec']) {
-        this.inner = this.inner.fork(Zone['wtfZoneSpec']);
+      if ((Zone as any /** TODO #9100 */)['wtfZoneSpec']) {
+        this.inner = this.inner.fork((Zone as any /** TODO #9100 */)['wtfZoneSpec']);
       }
-      if (trace && Zone['longStackTraceZoneSpec']) {
-        this.inner = this.inner.fork(Zone['longStackTraceZoneSpec']);
+      if (trace && (Zone as any /** TODO #9100 */)['longStackTraceZoneSpec']) {
+        this.inner = this.inner.fork((Zone as any /** TODO #9100 */)['longStackTraceZoneSpec']);
       }
       this.inner = this.inner.fork({
         name: 'angular',
diff --git a/modules/@angular/core/test/animation/active_animations_players_map_spec.ts b/modules/@angular/core/test/animation/active_animations_players_map_spec.ts
index 97481932cc..a563139d53 100644
--- a/modules/@angular/core/test/animation/active_animations_players_map_spec.ts
+++ b/modules/@angular/core/test/animation/active_animations_players_map_spec.ts
@@ -25,8 +25,8 @@ import {ActiveAnimationPlayersMap} from '../../src/animation/active_animation_pl
 
 export function main() {
   describe('ActiveAnimationsPlayersMap', function() {
-    var playersMap;
-    var elementNode;
+    var playersMap: any /** TODO #9100 */;
+    var elementNode: any /** TODO #9100 */;
     var animationName = 'animationName';
 
     beforeEach(() => {
diff --git a/modules/@angular/core/test/animation/animation_group_player_spec.ts b/modules/@angular/core/test/animation/animation_group_player_spec.ts
index 01025e7139..f5d943c239 100644
--- a/modules/@angular/core/test/animation/animation_group_player_spec.ts
+++ b/modules/@angular/core/test/animation/animation_group_player_spec.ts
@@ -22,7 +22,7 @@ import {MockAnimationPlayer} from '../../testing/animation/mock_animation_player
 
 export function main() {
   describe('AnimationGroupPlayer', function() {
-    var players;
+    var players: any /** TODO #9100 */;
     beforeEach(() => {
       players = [
         new MockAnimationPlayer(),
diff --git a/modules/@angular/core/test/animation/animation_integration_spec.ts b/modules/@angular/core/test/animation/animation_integration_spec.ts
index ba8dde4f63..e64880112b 100644
--- a/modules/@angular/core/test/animation/animation_integration_spec.ts
+++ b/modules/@angular/core/test/animation/animation_integration_spec.ts
@@ -58,7 +58,7 @@ function declareTests() {
   describe('animation tests', function() {
     beforeEachProviders(() => [{provide: AnimationDriver, useClass: MockAnimationDriver}]);
 
-    var makeAnimationCmp = (tcb: TestComponentBuilder, tpl: string, animationEntry: AnimationEntryMetadata|AnimationEntryMetadata[], callback = null) => {
+    var makeAnimationCmp = (tcb: TestComponentBuilder, tpl: string, animationEntry: AnimationEntryMetadata|AnimationEntryMetadata[], callback: any /** TODO #9100 */ = null) => {
       var entries = isArray(animationEntry)
           ? <AnimationEntryMetadata[]>animationEntry
           : [<AnimationEntryMetadata>animationEntry];
@@ -81,7 +81,7 @@ function declareTests() {
                               style({'opacity': 1}))
                           ])
                         ]),
-                                       (fixture) => {
+                                       (fixture: any /** TODO #9100 */) => {
                                          var cmp = fixture.debugElement.componentInstance;
                                          cmp.exp = true;
                                          fixture.detectChanges();
@@ -108,7 +108,7 @@ function declareTests() {
                               style({'opacity': 0}))
                           ])
                         ]),
-                                       (fixture) => {
+                                       (fixture: any /** TODO #9100 */) => {
                                          var cmp = fixture.debugElement.componentInstance;
                                          cmp.exp = true;
                                          fixture.detectChanges();
@@ -223,7 +223,7 @@ function declareTests() {
 
       describe('groups/sequences', () => {
         var assertPlaying =
-            (player: MockAnimationDriver, isPlaying) => {
+            (player: MockAnimationDriver, isPlaying: any /** TODO #9100 */) => {
               var method = 'play';
               var lastEntry = player.log.length > 0 ? player.log[player.log.length - 1] : null;
               if (isPresent(lastEntry)) {
@@ -570,7 +570,7 @@ function declareTests() {
                           transition('* => void', [
                             animate(1000, style({'opacity': 0}))
                           ])
-                        ]), (fixture) => {
+                        ]), (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -601,7 +601,7 @@ function declareTests() {
                             animate(1000, style({'opacity': 0})),
                             animate(1000, style({'opacity': 1}))
                           ])
-                        ]), (fixture) => {
+                        ]), (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -636,7 +636,7 @@ function declareTests() {
                             animate(1000, style({'width': 1000}))
                           ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -686,7 +686,7 @@ function declareTests() {
                           state('final', style({ "top": '100px' })),
                           transition('* => final', [ animate(1000) ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -712,7 +712,7 @@ function declareTests() {
                           state('red', style({ "background": 'red' })),
                           transition('* => *', [ animate(1000) ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -761,7 +761,7 @@ function declareTests() {
                           state('void', style({ "height": '100px' })),
                           transition('* => *', [ animate(1000) ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -784,7 +784,7 @@ function declareTests() {
                           state('void', style({ "width": '0px' })),
                           state('final', style({ "width": '100px' })),
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -807,7 +807,7 @@ function declareTests() {
                           state('a, c', style({ "height": '100px' })),
                           state('b, d', style({ "width": '100px' })),
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -866,7 +866,7 @@ function declareTests() {
                             animate(300)
                           ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
@@ -908,7 +908,7 @@ function declareTests() {
                             animate(1000)
                           ])
                         ])
-                    ], (fixture) => {
+                    ], (fixture: any /** TODO #9100 */) => {
                      tick();
 
                      var cmp = fixture.debugElement.componentInstance;
diff --git a/modules/@angular/core/test/animation/animation_sequence_player_spec.ts b/modules/@angular/core/test/animation/animation_sequence_player_spec.ts
index 88f2656054..c7c8074ec1 100644
--- a/modules/@angular/core/test/animation/animation_sequence_player_spec.ts
+++ b/modules/@angular/core/test/animation/animation_sequence_player_spec.ts
@@ -22,7 +22,7 @@ import {MockAnimationPlayer} from '../../testing/animation/mock_animation_player
 
 export function main() {
   describe('AnimationSequencePlayer', function() {
-    var players;
+    var players: any /** TODO #9100 */;
     beforeEach(() => {
       players = [
         new MockAnimationPlayer(),
diff --git a/modules/@angular/core/test/animation/animation_style_util_spec.ts b/modules/@angular/core/test/animation/animation_style_util_spec.ts
index bb320e7ee6..9ba6675bf9 100644
--- a/modules/@angular/core/test/animation/animation_style_util_spec.ts
+++ b/modules/@angular/core/test/animation/animation_style_util_spec.ts
@@ -127,9 +127,9 @@ export function main() {
           "color": "red"
         };
         var expectedResult = {
-          "opacity": null,
-          "width": null,
-          "color": null
+          "opacity": null as number,
+          "width": null as number,
+          "color": null as string
         };
         expect(animationUtils.clearStyles(styles)).toEqual(expectedResult);
       });
diff --git a/modules/@angular/core/test/application_ref_spec.ts b/modules/@angular/core/test/application_ref_spec.ts
index ee96609de9..33c330d36f 100644
--- a/modules/@angular/core/test/application_ref_spec.ts
+++ b/modules/@angular/core/test/application_ref_spec.ts
@@ -89,7 +89,7 @@ export function main() {
         });
 
         it('should return a promise with rejected errors even if the exceptionHandler is not rethrowing',
-           inject([AsyncTestCompleter, Injector], (async, injector) => {
+           inject([AsyncTestCompleter, Injector], (async: any /** TODO #9100 */, injector: any /** TODO #9100 */) => {
              var ref = createApplication([]);
              var promise = ref.run(() => PromiseWrapper.reject('Test', null));
              PromiseWrapper.catchError(promise, (e) => {
@@ -102,7 +102,7 @@ export function main() {
 
     describe("coreLoadAndBootstrap", () => {
       it("should wait for asynchronous app initializers",
-         inject([AsyncTestCompleter, Injector], (async, injector) => {
+         inject([AsyncTestCompleter, Injector], (async: any /** TODO #9100 */, injector: any /** TODO #9100 */) => {
            let completer: PromiseCompleter<any> = PromiseWrapper.completer();
            var initializerDone = false;
            TimerWrapper.setTimeout(() => {
@@ -121,7 +121,7 @@ export function main() {
 
     describe("coreBootstrap", () => {
       it("should throw if an APP_INITIIALIZER is not yet resolved",
-         inject([Injector], (injector) => {
+         inject([Injector], (injector: any /** TODO #9100 */) => {
            var app = createApplication([
              {provide: APP_INITIALIZER, useValue: () => PromiseWrapper.completer().promise, multi: true}
            ]);
@@ -170,6 +170,6 @@ class _MockComponentRef extends ComponentRef_<any> {
 }
 
 class _MockConsole implements Console {
-  log(message) {}
-  warn(message) {}
+  log(message: any /** TODO #9100 */) {}
+  warn(message: any /** TODO #9100 */) {}
 }
diff --git a/modules/@angular/core/test/change_detection/differs/default_iterable_differ_spec.ts b/modules/@angular/core/test/change_detection/differs/default_iterable_differ_spec.ts
index 521310f8d0..4593d56013 100644
--- a/modules/@angular/core/test/change_detection/differs/default_iterable_differ_spec.ts
+++ b/modules/@angular/core/test/change_detection/differs/default_iterable_differ_spec.ts
@@ -35,7 +35,7 @@ class ComplexItem {
 export function main() {
   describe('iterable differ', function() {
     describe('DefaultIterableDiffer', function() {
-      var differ;
+      var differ: any /** TODO #9100 */;
 
       beforeEach(() => { differ = new DefaultIterableDiffer(); });
 
@@ -71,7 +71,7 @@ export function main() {
       });
 
       it('should detect additions', () => {
-        let l = [];
+        let l: any[] /** TODO #9100 */ = [];
         differ.check(l);
         expect(differ.toString()).toEqual(iterableChangesAsString({collection: []}));
 
@@ -155,7 +155,7 @@ export function main() {
       });
 
       it('should detect changes in list', () => {
-        let l = [];
+        let l: any[] /** TODO #9100 */ = [];
         differ.check(l);
 
         l.push('a');
@@ -339,7 +339,7 @@ export function main() {
     });
 
     describe('trackBy function by id', function() {
-      var differ;
+      var differ: any /** TODO #9100 */;
 
       var trackByItemId = (index: number, item: any): any => item.id;
 
@@ -434,7 +434,7 @@ export function main() {
       });
     });
     describe('trackBy function by index', function() {
-      var differ;
+      var differ: any /** TODO #9100 */;
 
       var trackByIndex = (index: number, item: any): number => index;
 
diff --git a/modules/@angular/core/test/change_detection/differs/default_keyvalue_differ_spec.ts b/modules/@angular/core/test/change_detection/differs/default_keyvalue_differ_spec.ts
index ae7d795540..779003fd64 100644
--- a/modules/@angular/core/test/change_detection/differs/default_keyvalue_differ_spec.ts
+++ b/modules/@angular/core/test/change_detection/differs/default_keyvalue_differ_spec.ts
@@ -19,7 +19,7 @@ import {kvChangesAsString} from '../../change_detection/util';
 export function main() {
   describe('keyvalue differ', function() {
     describe('DefaultKeyValueDiffer', function() {
-      var differ;
+      var differ: any /** TODO #9100 */;
       var m: Map<any, any>;
 
       beforeEach(() => {
@@ -61,7 +61,7 @@ export function main() {
       });
 
       it('should expose previous and current value', () => {
-        var previous, current;
+        var previous: any /** TODO #9100 */, current: any /** TODO #9100 */;
 
         m.set(1, 10);
         differ.check(m);
@@ -69,7 +69,7 @@ export function main() {
         m.set(1, 20);
         differ.check(m);
 
-        differ.forEachChangedItem((record) => {
+        differ.forEachChangedItem((record: any /** TODO #9100 */) => {
           previous = record.previousValue;
           current = record.currentValue;
         });
@@ -154,19 +154,19 @@ export function main() {
             let m = {};
             differ.check(m);
 
-            m['a'] = 'A';
+            (m as any /** TODO #9100 */)['a'] = 'A';
             differ.check(m);
             expect(differ.toString())
                 .toEqual(kvChangesAsString({map: ['a[null->A]'], additions: ['a[null->A]']}));
 
-            m['b'] = 'B';
+            (m as any /** TODO #9100 */)['b'] = 'B';
             differ.check(m);
             expect(differ.toString())
                 .toEqual(kvChangesAsString(
                     {map: ['a', 'b[null->B]'], previous: ['a'], additions: ['b[null->B]']}));
 
-            m['b'] = 'BB';
-            m['d'] = 'D';
+            (m as any /** TODO #9100 */)['b'] = 'BB';
+            (m as any /** TODO #9100 */)['d'] = 'D';
             differ.check(m);
             expect(differ.toString())
                 .toEqual(kvChangesAsString({
@@ -177,8 +177,8 @@ export function main() {
                 }));
 
             m = {};
-            m['a'] = 'A';
-            m['d'] = 'D';
+            (m as any /** TODO #9100 */)['a'] = 'A';
+            (m as any /** TODO #9100 */)['d'] = 'D';
             differ.check(m);
             expect(differ.toString())
                 .toEqual(kvChangesAsString({
diff --git a/modules/@angular/core/test/change_detection/differs/iterable_differs_spec.ts b/modules/@angular/core/test/change_detection/differs/iterable_differs_spec.ts
index 9a81d6d1cf..75f41cca37 100644
--- a/modules/@angular/core/test/change_detection/differs/iterable_differs_spec.ts
+++ b/modules/@angular/core/test/change_detection/differs/iterable_differs_spec.ts
@@ -14,9 +14,9 @@ import {Injector, provide, ReflectiveInjector} from '@angular/core';
 
 export function main() {
   describe('IterableDiffers', function() {
-    var factory1;
-    var factory2;
-    var factory3;
+    var factory1: any /** TODO #9100 */;
+    var factory2: any /** TODO #9100 */;
+    var factory3: any /** TODO #9100 */;
 
     beforeEach(() => {
       factory1 = new SpyIterableDifferFactory();
diff --git a/modules/@angular/core/test/change_detection/iterable.ts b/modules/@angular/core/test/change_detection/iterable.ts
index 0c64783651..7807fc3421 100644
--- a/modules/@angular/core/test/change_detection/iterable.ts
+++ b/modules/@angular/core/test/change_detection/iterable.ts
@@ -4,5 +4,5 @@ export class TestIterable {
   list: number[];
   constructor() { this.list = []; }
 
-  [getSymbolIterator()]() { return this.list[getSymbolIterator()](); }
+  [getSymbolIterator()]() { return (this.list as any)[getSymbolIterator()](); }
 }
diff --git a/modules/@angular/core/test/change_detection/util.ts b/modules/@angular/core/test/change_detection/util.ts
index 71e5dff25f..4544ed8978 100644
--- a/modules/@angular/core/test/change_detection/util.ts
+++ b/modules/@angular/core/test/change_detection/util.ts
@@ -1,9 +1,9 @@
 import {isBlank} from '../../src/facade/lang';
 
 export function iterableChangesAsString(
-    {collection = /*@ts2dart_const*/[], previous = /*@ts2dart_const*/[],
-     additions = /*@ts2dart_const*/[], moves = /*@ts2dart_const*/[],
-     removals = /*@ts2dart_const*/[], identityChanges = /*@ts2dart_const*/[]}) {
+    {collection = /*@ts2dart_const*/[] as any, previous = /*@ts2dart_const*/[] as any,
+     additions = /*@ts2dart_const*/[] as any, moves = /*@ts2dart_const*/[] as any,
+     removals = /*@ts2dart_const*/[] as any, identityChanges = /*@ts2dart_const*/[] as any}): string {
   return "collection: " + collection.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" +
          "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" +
          "removals: " + removals.join(', ') + "\n" + "identityChanges: " +
diff --git a/modules/@angular/core/test/debug/debug_node_spec.ts b/modules/@angular/core/test/debug/debug_node_spec.ts
index fb9944e4d0..1290bf677e 100644
--- a/modules/@angular/core/test/debug/debug_node_spec.ts
+++ b/modules/@angular/core/test/debug/debug_node_spec.ts
@@ -39,7 +39,7 @@ class MessageDir {
 
   constructor(logger: Logger) { this.logger = logger; }
 
-  set message(newMessage) { this.logger.add(newMessage); }
+  set message(newMessage: any /** TODO #9100 */) { this.logger.add(newMessage); }
 }
 
 @Component({
@@ -193,7 +193,7 @@ class TestApp {
 export function main() {
   describe('debug element', function() {
     it('should list all child nodes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(ParentComp)
              .then((fixture) => {
                fixture.detectChanges();
@@ -205,7 +205,7 @@ export function main() {
        }));
 
     it('should list all component child elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(ParentComp)
              .then((fixture) => {
@@ -239,7 +239,7 @@ export function main() {
        }));
 
     it('should list conditional component child elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(ConditionalParentComp)
              .then((fixture) => {
                fixture.detectChanges();
@@ -265,7 +265,7 @@ export function main() {
        }));
 
     it('should list child elements within viewports',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(UsingFor).then((fixture) => {
            fixture.detectChanges();
 
@@ -282,7 +282,7 @@ export function main() {
        }));
 
     it('should list element attributes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(TestApp).then((fixture) => {
            fixture.detectChanges();
            var bankElem = fixture.debugElement.children[0];
@@ -294,7 +294,7 @@ export function main() {
        }));
 
     it('should list element classes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(TestApp).then((fixture) => {
            fixture.detectChanges();
            var bankElem = fixture.debugElement.children[0];
@@ -306,7 +306,7 @@ export function main() {
        }));
 
     it('should list element styles',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(TestApp).then((fixture) => {
            fixture.detectChanges();
            var bankElem = fixture.debugElement.children[0];
@@ -318,7 +318,7 @@ export function main() {
        }));
 
     it('should query child elements by css',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(ParentComp)
              .then((fixture) => {
                fixture.detectChanges();
@@ -334,7 +334,7 @@ export function main() {
        }));
 
     it('should query child elements by directive',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(ParentComp)
              .then((fixture) => {
                fixture.detectChanges();
@@ -352,7 +352,7 @@ export function main() {
        }));
 
     it('should list providerTokens',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(ParentComp)
              .then((fixture) => {
@@ -365,7 +365,7 @@ export function main() {
        }));
 
     it('should list locals',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(LocalsComp)
              .then((fixture) => {
                fixture.detectChanges();
@@ -377,7 +377,7 @@ export function main() {
        }));
 
     it('should allow injecting from the element injector',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(ParentComp)
              .then((fixture) => {
@@ -391,7 +391,7 @@ export function main() {
        }));
 
     it('should list event listeners',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(EventsComp)
              .then((fixture) => {
@@ -406,7 +406,7 @@ export function main() {
 
 
     it('should trigger event handlers',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.createAsync(EventsComp)
              .then((fixture) => {
diff --git a/modules/@angular/core/test/di/reflective_injector_spec.ts b/modules/@angular/core/test/di/reflective_injector_spec.ts
index f71dfee7da..f551e50610 100644
--- a/modules/@angular/core/test/di/reflective_injector_spec.ts
+++ b/modules/@angular/core/test/di/reflective_injector_spec.ts
@@ -46,7 +46,7 @@ class Car {
 
 @Injectable()
 class CarWithOptionalEngine {
-  engine;
+  engine: any /** TODO #9100 */;
   constructor(@Optional() engine: Engine) { this.engine = engine; }
 }
 
@@ -78,10 +78,10 @@ class CyclicEngine {
 }
 
 class NoAnnotations {
-  constructor(secretDependency) {}
+  constructor(secretDependency: any /** TODO #9100 */) {}
 }
 
-function factoryFn(a) {}
+function factoryFn(a: any /** TODO #9100 */) {}
 
 export function main() {
   var dynamicProviders = [
@@ -176,7 +176,7 @@ export function main() {
       });
 
       it('should provide to a factory', () => {
-        function sportsCarFactory(e) { return new SportsCar(e); }
+        function sportsCarFactory(e: any /** TODO #9100 */) { return new SportsCar(e); }
 
         var injector =
             createInjector([Engine, {provide: Car, useFactory: sportsCarFactory, deps: [Engine]}]);
@@ -290,7 +290,7 @@ export function main() {
 
       it('should support overriding factory dependencies', () => {
         var injector = createInjector(
-            [Engine, {provide: Car, useFactory: (e) => new SportsCar(e), deps: [Engine]}]);
+            [Engine, {provide: Car, useFactory: (e: any /** TODO #9100 */) => new SportsCar(e), deps: [Engine]}]);
 
         var car = injector.get(Car);
         expect(car).toBeAnInstanceOf(SportsCar);
@@ -483,7 +483,7 @@ export function main() {
         it("should return a dependency from self", () => {
           var inj = ReflectiveInjector.resolveAndCreate([
             Engine,
-            {provide: Car, useFactory: (e) => new Car(e), deps: [[Engine, new SelfMetadata()]]}
+            {provide: Car, useFactory: (e: any /** TODO #9100 */) => new Car(e), deps: [[Engine, new SelfMetadata()]]}
           ]);
 
           expect(inj.get(Car)).toBeAnInstanceOf(Car);
@@ -492,7 +492,7 @@ export function main() {
         it("should throw when not requested provider on self", () => {
           var parent = ReflectiveInjector.resolveAndCreate([Engine]);
           var child = parent.resolveAndCreateChild([
-            {provide: Car, useFactory: (e) => new Car(e), deps: [[Engine, new SelfMetadata()]]}
+            {provide: Car, useFactory: (e: any /** TODO #9100 */) => new Car(e), deps: [[Engine, new SelfMetadata()]]}
           ]);
 
           expect(() => child.get(Car))
@@ -505,7 +505,7 @@ export function main() {
           var parent = ReflectiveInjector.resolveAndCreate([Engine]);
           var child = parent.resolveAndCreateChild([
             {provide: Engine, useClass: TurboEngine},
-            {provide: Car, useFactory: (e) => new Car(e), deps: [Engine]}
+            {provide: Car, useFactory: (e: any /** TODO #9100 */) => new Car(e), deps: [Engine]}
           ]);
 
           expect(child.get(Car).engine).toBeAnInstanceOf(TurboEngine);
@@ -596,7 +596,7 @@ export function main() {
                     var providers = ReflectiveInjector.resolve([
                       {
                         provide: "token",
-                        useFactory: (e) => "result",
+                        useFactory: (e: any /** TODO #9100 */) => "result",
                         deps: [[new InjectMetadata("dep"), new CustomDependencyMetadata()]]
                       }
                     ]);
@@ -610,9 +610,9 @@ export function main() {
 
                it('should allow declaring dependencies with flat arrays', () => {
                  var resolved = ReflectiveInjector.resolve(
-                     [{provide: 'token', useFactory: e => e, deps: [new InjectMetadata("dep")]}]);
+                     [{provide: 'token', useFactory: (e: any /** TODO #9100 */) => e, deps: [new InjectMetadata("dep")]}]);
                  var nestedResolved = ReflectiveInjector.resolve(
-                     [{provide: 'token', useFactory: e => e, deps: [[new InjectMetadata("dep")]]}]);
+                     [{provide: 'token', useFactory: (e: any /** TODO #9100 */) => e, deps: [[new InjectMetadata("dep")]]}]);
                  expect(resolved[0].resolvedFactories[0].dependencies[0].key.token)
                      .toEqual(nestedResolved[0].resolvedFactories[0].dependencies[0].key.token);
                });
diff --git a/modules/@angular/core/test/directive_lifecycle_integration_spec.ts b/modules/@angular/core/test/directive_lifecycle_integration_spec.ts
index 8ba50e3704..27bd043e85 100644
--- a/modules/@angular/core/test/directive_lifecycle_integration_spec.ts
+++ b/modules/@angular/core/test/directive_lifecycle_integration_spec.ts
@@ -29,7 +29,7 @@ export function main() {
 
     it('should invoke lifecycle methods ngOnChanges > ngOnInit > ngDoCheck > ngAfterContentChecked',
        inject([TestComponentBuilder, Log, AsyncTestCompleter], (tcb: TestComponentBuilder, log: Log,
-                                                                async) => {
+                                                                async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 MyComp5,
                 new ViewMetadata(
@@ -71,10 +71,10 @@ class LifecycleDir implements DoCheck {
 })
 class LifecycleCmp implements OnChanges,
     OnInit, DoCheck, AfterContentInit, AfterContentChecked, AfterViewInit, AfterViewChecked {
-  field;
+  field: any /** TODO #9100 */;
   constructor(private _log: Log) {}
 
-  ngOnChanges(_) { this._log.add("ngOnChanges"); }
+  ngOnChanges(_: any /** TODO #9100 */) { this._log.add("ngOnChanges"); }
 
   ngOnInit() { this._log.add("ngOnInit"); }
 
diff --git a/modules/@angular/core/test/dom/shim_spec.ts b/modules/@angular/core/test/dom/shim_spec.ts
index a9951bb991..59e1f76cda 100644
--- a/modules/@angular/core/test/dom/shim_spec.ts
+++ b/modules/@angular/core/test/dom/shim_spec.ts
@@ -13,8 +13,8 @@ export function main() {
   describe('Shim', () => {
 
     it('should provide correct function.name ', () => {
-      var functionWithoutName = identity(() => function(_) {});
-      function foo(_){};
+      var functionWithoutName = identity(() => function(_: any /** TODO #9100 */) {});
+      function foo(_: any /** TODO #9100 */){};
 
       expect((<any>functionWithoutName).name).toBeFalsy();
       expect((<any>foo).name).toEqual('foo');
@@ -23,6 +23,6 @@ export function main() {
   });
 }
 
-function identity(a) {
+function identity(a: any /** TODO #9100 */) {
   return a;
 }
diff --git a/modules/@angular/core/test/facade/observable_spec.ts b/modules/@angular/core/test/facade/observable_spec.ts
index c0d6785da2..87acef5bb2 100644
--- a/modules/@angular/core/test/facade/observable_spec.ts
+++ b/modules/@angular/core/test/facade/observable_spec.ts
@@ -16,9 +16,9 @@ export function main() {
   describe("Observable", () => {
     describe("#core", () => {
 
-      it("should call next with values", inject([AsyncTestCompleter], (async) => {
+      it("should call next with values", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
-           let o = new Observable(sink => { sink.next(1); });
+           let o = new Observable((sink: any /** TODO #9100 */) => { sink.next(1); });
 
            o.subscribe(v => {
              expect(v).toEqual(1);
@@ -27,9 +27,9 @@ export function main() {
 
          }));
 
-      it("should call next and then complete", inject([AsyncTestCompleter], (async) => {
+      it("should call next and then complete", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
-           let o = new Observable(sink => {
+           let o = new Observable((sink: any /** TODO #9100 */) => {
              sink.next(1);
              sink.complete();
            });
@@ -42,9 +42,9 @@ export function main() {
 
          }));
 
-      it("should call error with errors", inject([AsyncTestCompleter], (async) => {
+      it("should call error with errors", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
-           let o = new Observable(sink => { sink.error('oh noes!'); });
+           let o = new Observable((sink: any /** TODO #9100 */) => { sink.error('oh noes!'); });
 
            o.subscribe(
                v => {
diff --git a/modules/@angular/core/test/fake_async_spec.ts b/modules/@angular/core/test/fake_async_spec.ts
index f756fc55b1..d74cea211e 100644
--- a/modules/@angular/core/test/fake_async_spec.ts
+++ b/modules/@angular/core/test/fake_async_spec.ts
@@ -29,17 +29,17 @@ export function main() {
     });
 
     it('should pass arguments to the wrapped function', () => {
-      fakeAsync((foo, bar) => {
+      fakeAsync((foo: any /** TODO #9100 */, bar: any /** TODO #9100 */) => {
         expect(foo).toEqual('foo');
         expect(bar).toEqual('bar');
       })('foo', 'bar');
     });
 
     it('should work with inject()',
-       fakeAsync(inject([Parser], (parser) => { expect(parser).toBeAnInstanceOf(Parser); })));
+       fakeAsync(inject([Parser], (parser: any /** TODO #9100 */) => { expect(parser).toBeAnInstanceOf(Parser); })));
 
     it('should throw on nested calls', () => {
-      expect(() => { fakeAsync(() => { fakeAsync(() => null)(); })(); })
+      expect(() => { fakeAsync(() => { fakeAsync((): any /** TODO #9100 */ => null)(); })(); })
           .toThrowError('fakeAsync() calls can not be nested');
     });
 
@@ -191,7 +191,7 @@ export function main() {
 
       it('should be able to cancel periodic timers from a callback', fakeAsync(() => {
            var cycles = 0;
-           var id;
+           var id: any /** TODO #9100 */;
 
            id = TimerWrapper.setInterval(() => {
              cycles++;
diff --git a/modules/@angular/core/test/forward_ref_integration_spec.ts b/modules/@angular/core/test/forward_ref_integration_spec.ts
index 14059bc439..2561d851ad 100644
--- a/modules/@angular/core/test/forward_ref_integration_spec.ts
+++ b/modules/@angular/core/test/forward_ref_integration_spec.ts
@@ -28,7 +28,7 @@ import {asNativeElements} from '@angular/core';
 export function main() {
   describe("forwardRef integration", function() {
     it('should instantiate components which are declared using forwardRef',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.createAsync(App).then((tc) => {
            tc.detectChanges();
            expect(asNativeElements(tc.debugElement.children)).toHaveText('frame(lock)');
diff --git a/modules/@angular/core/test/linker/change_detection_integration_spec.ts b/modules/@angular/core/test/linker/change_detection_integration_spec.ts
index 50bbeb238f..388ad9373b 100644
--- a/modules/@angular/core/test/linker/change_detection_integration_spec.ts
+++ b/modules/@angular/core/test/linker/change_detection_integration_spec.ts
@@ -130,7 +130,7 @@ export function main() {
     ]);
 
     beforeEach(inject([TestComponentBuilder, ElementSchemaRegistry, RenderLog, DirectiveLog],
-                      (_tcb, _elSchema, _renderLog, _directiveLog) => {
+                      (_tcb: any /** TODO #9100 */, _elSchema: any /** TODO #9100 */, _renderLog: any /** TODO #9100 */, _directiveLog: any /** TODO #9100 */) => {
                         tcb = _tcb;
                         elSchema = _elSchema;
                         renderLog = _renderLog;
@@ -329,7 +329,7 @@ export function main() {
 
       it('should support function calls', fakeAsync(() => {
            var ctx = _bindSimpleValue('a()(99)', TestData);
-           ctx.componentInstance.a = () => (a) => a;
+           ctx.componentInstance.a = () => (a: any /** TODO #9100 */) => a;
            ctx.detectChanges(false);
            expect(renderLog.log).toEqual(['someProp=99']);
          }));
@@ -1188,13 +1188,13 @@ class DirectiveLog {
 @Pipe({name: 'countingPipe'})
 class CountingPipe implements PipeTransform {
   state: number = 0;
-  transform(value) { return `${value} state:${this.state ++}`; }
+  transform(value: any /** TODO #9100 */) { return `${value} state:${this.state ++}`; }
 }
 
 @Pipe({name: 'countingImpurePipe', pure: false})
 class CountingImpurePipe implements PipeTransform {
   state: number = 0;
-  transform(value) { return `${value} state:${this.state ++}`; }
+  transform(value: any /** TODO #9100 */) { return `${value} state:${this.state ++}`; }
 }
 
 @Pipe({name: 'pipeWithOnDestroy'})
@@ -1203,22 +1203,22 @@ class PipeWithOnDestroy implements PipeTransform, OnDestroy {
 
   ngOnDestroy() { this.directiveLog.add('pipeWithOnDestroy', 'ngOnDestroy'); }
 
-  transform(value) { return null; }
+  transform(value: any /** TODO #9100 */): any /** TODO #9100 */ { return null; }
 }
 
 @Pipe({name: 'identityPipe'})
 class IdentityPipe implements PipeTransform {
-  transform(value) { return value; }
+  transform(value: any /** TODO #9100 */) { return value; }
 }
 
 @Pipe({name: 'wrappedPipe'})
 class WrappedPipe implements PipeTransform {
-  transform(value) { return WrappedValue.wrap(value); }
+  transform(value: any /** TODO #9100 */) { return WrappedValue.wrap(value); }
 }
 
 @Pipe({name: 'multiArgPipe'})
 class MultiArgPipe implements PipeTransform {
-  transform(value, arg1, arg2, arg3 = 'default') { return `${value} ${arg1} ${arg2} ${arg3}`; }
+  transform(value: any /** TODO #9100 */, arg1: any /** TODO #9100 */, arg2: any /** TODO #9100 */, arg3 = 'default') { return `${value} ${arg1} ${arg2} ${arg3}`; }
 }
 
 @Component({selector: 'test-cmp', template: '', directives: ALL_DIRECTIVES, pipes: ALL_PIPES})
@@ -1271,10 +1271,10 @@ class EmitterDirective {
 @Directive({selector: '[testDirective]', exportAs: 'testDirective'})
 class TestDirective implements OnInit, DoCheck, OnChanges, AfterContentInit, AfterContentChecked,
     AfterViewInit, AfterViewChecked, OnDestroy {
-  @Input() a;
-  @Input() b;
-  changes;
-  event;
+  @Input() a: any /** TODO #9100 */;
+  @Input() b: any /** TODO #9100 */;
+  changes: any /** TODO #9100 */;
+  event: any /** TODO #9100 */;
   eventEmitter: EventEmitter<string> = new EventEmitter<string>();
 
   @Input('testDirective') name: string;
@@ -1283,7 +1283,7 @@ class TestDirective implements OnInit, DoCheck, OnChanges, AfterContentInit, Aft
 
   constructor(public log: DirectiveLog) {}
 
-  onEvent(event) { this.event = event; }
+  onEvent(event: any /** TODO #9100 */) { this.event = event; }
 
   ngDoCheck() { this.log.add(this.name, 'ngDoCheck'); }
 
@@ -1294,10 +1294,10 @@ class TestDirective implements OnInit, DoCheck, OnChanges, AfterContentInit, Aft
     }
   }
 
-  ngOnChanges(changes) {
+  ngOnChanges(changes: any /** TODO #9100 */) {
     this.log.add(this.name, 'ngOnChanges');
     var r = {};
-    StringMapWrapper.forEach(changes, (c, key) => r[key] = c.currentValue);
+    StringMapWrapper.forEach(changes, (c: any /** TODO #9100 */, key: any /** TODO #9100 */) => (r as any /** TODO #9100 */)[key] = c.currentValue);
     this.changes = r;
     if (this.throwOn == 'ngOnChanges') {
       throw new BaseException('Boom!');
@@ -1401,9 +1401,9 @@ class Person {
     this.address = address;
   }
 
-  sayHi(m) { return `Hi, ${m}`; }
+  sayHi(m: any /** TODO #9100 */) { return `Hi, ${m}`; }
 
-  passThrough(val) { return val; }
+  passThrough(val: any /** TODO #9100 */) { return val; }
 
   toString(): string {
     var address = this.address == null ? '' : ' address=' + this.address.toString();
@@ -1416,7 +1416,7 @@ class Address {
   cityGetterCalls: number = 0;
   zipCodeGetterCalls: number = 0;
 
-  constructor(public _city: string, public _zipcode = null) {}
+  constructor(public _city: string, public _zipcode: any /** TODO #9100 */ = null) {}
 
   get city() {
     this.cityGetterCalls++;
diff --git a/modules/@angular/core/test/linker/dynamic_component_loader_spec.ts b/modules/@angular/core/test/linker/dynamic_component_loader_spec.ts
index de972d7584..e972247643 100644
--- a/modules/@angular/core/test/linker/dynamic_component_loader_spec.ts
+++ b/modules/@angular/core/test/linker/dynamic_component_loader_spec.ts
@@ -28,7 +28,7 @@ export function main() {
     describe("loading next to a location", () => {
       it('should work',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   tcb.createAsync(MyComp3).then((tc) => {
                     tc.detectChanges();
                     loader.loadNextToLocation(DynamicallyLoaded,
@@ -44,7 +44,7 @@ export function main() {
       it('should return a disposable component ref',
          inject(
              [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+             (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                tcb.createAsync(MyComp3).then((tc) => {
                  tc.detectChanges();
                  loader.loadNextToLocation(DynamicallyLoaded, tc.componentInstance.viewContainerRef)
@@ -67,7 +67,7 @@ export function main() {
 
       it('should update host properties',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   tcb.createAsync(MyComp3).then((tc) => {
                     tc.detectChanges();
 
@@ -90,7 +90,7 @@ export function main() {
 
       it('should leave the view tree in a consistent state if hydration fails',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   tcb.createAsync(MyComp3).then((tc: ComponentFixture<any>) => {
                     tc.detectChanges();
                     PromiseWrapper.catchError(
@@ -107,7 +107,7 @@ export function main() {
 
       it('should allow to pass projectable nodes',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   tcb.createAsync(MyComp3).then((tc) => {
                     tc.detectChanges();
                     loader.loadNextToLocation(DynamicallyLoadedWithNgContent,
@@ -124,7 +124,7 @@ export function main() {
 
       it('should not throw if not enough projectable nodes are passed in',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
-                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async) => {
+                (loader: DynamicComponentLoader, tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                   tcb.createAsync(MyComp3).then((tc) => {
                     tc.detectChanges();
                     loader.loadNextToLocation(DynamicallyLoadedWithNgContent,
@@ -138,7 +138,7 @@ export function main() {
     describe('loadAsRoot', () => {
       it('should allow to create, update and destroy components',
          inject([AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
-                (async, loader: DynamicComponentLoader, doc, injector: Injector) => {
+                (async: any /** TODO #9100 */, loader: DynamicComponentLoader, doc: any /** TODO #9100 */, injector: Injector) => {
                   var rootEl = createRootElement(doc, 'child-cmp');
                   getDOM().appendChild(doc.body, rootEl);
                   loader.loadAsRoot(ChildComp, null, injector)
@@ -167,7 +167,7 @@ export function main() {
 
       it('should allow to pass projectable nodes',
          inject([AsyncTestCompleter, DynamicComponentLoader, DOCUMENT, Injector],
-                (async, loader: DynamicComponentLoader, doc, injector: Injector) => {
+                (async: any /** TODO #9100 */, loader: DynamicComponentLoader, doc: any /** TODO #9100 */, injector: Injector) => {
                   var rootEl = createRootElement(doc, 'dummy');
                   getDOM().appendChild(doc.body, rootEl);
                   loader.loadAsRoot(DynamicallyLoadedWithNgContent, null, injector, null,
diff --git a/modules/@angular/core/test/linker/integration_spec.ts b/modules/@angular/core/test/linker/integration_spec.ts
index f089002415..3290bdeb37 100644
--- a/modules/@angular/core/test/linker/integration_spec.ts
+++ b/modules/@angular/core/test/linker/integration_spec.ts
@@ -103,7 +103,7 @@ function declareTests(isJit: boolean) {
 
     describe('react to record changes', function() {
       it('should consume text node changes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({template: '<div>{{ctxProp}}</div>'}))
                .createAsync(MyComp)
                .then((fixture) => {
@@ -116,7 +116,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should update text node with a blank string when interpolation evaluates to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({template: '<div>{{null}}{{ctxProp}}</div>'}))
                .createAsync(MyComp)
                .then((fixture) => {
@@ -129,7 +129,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume element binding changes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({template: '<div [id]="ctxProp"></div>'}))
                .createAsync(MyComp)
                .then((fixture) => {
@@ -143,7 +143,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume binding to aria-* attributes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<div [attr.aria-label]="ctxProp"></div>'}))
 
@@ -166,7 +166,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should remove an attribute when attribute expression evaluates to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<div [attr.foo]="ctxProp"></div>'}))
 
@@ -190,7 +190,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should remove style when when style expression evaluates to null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<div [style.height.px]="ctxProp"></div>'}))
 
@@ -212,7 +212,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume binding to property names where attr name and property name do not match',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<div [tabindex]="ctxNumProp"></div>'}))
 
@@ -231,7 +231,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume binding to camel-cased properties',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<input [readOnly]="ctxBoolProp">'}))
 
@@ -250,7 +250,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume binding to innerHtml',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp,
                             new ViewMetadata({template: '<div innerHtml="{{ctxProp}}"></div>'}))
 
@@ -272,7 +272,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume binding to className using class alias',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata({template: '<div class="initial" [class]="ctxProp"></div>'}))
@@ -292,7 +292,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should consume directive watch expression change.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var tpl = '<span>' +
                      '<div my-dir [elprop]="ctxProp"></div>' +
                      '<div my-dir elprop="Hi there!"></div>' +
@@ -320,7 +320,7 @@ function declareTests(isJit: boolean) {
       describe('pipes', () => {
         it("should support pipes in bindings",
            inject(
-               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                  tcb.overrideView(
                         MyComp, new ViewMetadata({
                           template: '<div my-dir #dir="mydir" [elprop]="ctxProp | double"></div>',
@@ -341,7 +341,7 @@ function declareTests(isJit: boolean) {
       });
 
       it('should support nested components.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata({template: '<child-cmp></child-cmp>', directives: [ChildComp]}))
@@ -358,7 +358,7 @@ function declareTests(isJit: boolean) {
 
       // GH issue 328 - https://github.com/angular/angular/issues/328
       it('should support different directive types on a single node',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<child-cmp my-dir [elprop]="ctxProp"></child-cmp>',
                               directives: [MyDir, ChildComp]
@@ -380,7 +380,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support directives where a binding attribute is not given',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               // No attribute "el-prop" specified.
                               template: '<p my-dir></p>',
@@ -392,7 +392,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should execute a given directive once, even if specified multiple times',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: '<p no-duplicate></p>',
@@ -406,7 +406,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support directives where a selector matches property binding',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata(
                                         {template: '<p [id]="ctxProp"></p>', directives: [IdDir]}))
 
@@ -428,7 +428,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support directives where a selector matches event binding',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata(
@@ -443,7 +443,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should read directives metadata from their binding token',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<div public-api><div needs-public-api></div></div>',
                               directives: [PrivateImpl, NeedsPublicApi]
@@ -454,7 +454,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support template directives via `<template>` elements.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template:
@@ -477,7 +477,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should not detach views in ViewContainers when the parent view is destroyed.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template:
@@ -506,7 +506,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should use a comment while stamping out `<template>` elements.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({template: '<template></template>'}))
 
                .createAsync(MyComp)
@@ -519,7 +519,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support template directives via `template` attribute.',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template:
@@ -541,7 +541,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should allow to transplant TemplateRefs into other ViewContainers',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template:
@@ -564,7 +564,7 @@ function declareTests(isJit: boolean) {
       describe("reference bindings", () => {
         it('should assign a component to a ref-',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                       tcb.overrideView(MyComp, new ViewMetadata({
                                          template: '<p><child-cmp ref-alice></child-cmp></p>',
                                          directives: [ChildComp]
@@ -580,7 +580,7 @@ function declareTests(isJit: boolean) {
 
         it('should assign a directive to a ref-',
            inject(
-               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                  tcb.overrideView(MyComp, new ViewMetadata({
                                     template: '<div><div export-dir #localdir="dir"></div></div>',
                                     directives: [ExportDir]
@@ -598,7 +598,7 @@ function declareTests(isJit: boolean) {
         it('should make the assigned component accessible in property bindings, even if they were declared before the component',
            inject(
                [TestComponentBuilder, AsyncTestCompleter],
-               (tcb: TestComponentBuilder, async) => {
+               (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                    tcb.overrideView(
                           MyComp, new ViewMetadata({
                             template:
@@ -617,7 +617,7 @@ function declareTests(isJit: boolean) {
         it('should assign two component instances each with a ref-',
            inject(
                [TestComponentBuilder, AsyncTestCompleter],
-               (tcb: TestComponentBuilder, async) => {
+               (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                    tcb.overrideView(
                           MyComp, new ViewMetadata({
                             template:
@@ -641,7 +641,7 @@ function declareTests(isJit: boolean) {
         it('should assign the component instance to a ref- with shorthand syntax',
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder,
-                   async) => {tcb.overrideView(MyComp, new ViewMetadata({
+                   async: any /** TODO #9100 */) => {tcb.overrideView(MyComp, new ViewMetadata({
                                                  template: '<child-cmp #alice></child-cmp>',
                                                  directives: [ChildComp]
                                                }))
@@ -657,7 +657,7 @@ function declareTests(isJit: boolean) {
 
         it('should assign the element instance to a user-defined variable',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                       tcb.overrideView(MyComp, new ViewMetadata({
                                          template: '<div><div ref-alice><i>Hello</i></div></div>'
                                        }))
@@ -675,7 +675,7 @@ function declareTests(isJit: boolean) {
 
         it('should assign the TemplateRef to a user-defined variable',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                       tcb.overrideView(MyComp, new ViewMetadata(
                                                    {template: '<template ref-alice></template>'}))
 
@@ -690,7 +690,7 @@ function declareTests(isJit: boolean) {
 
         it('should preserve case',
            inject(
-               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                  tcb.overrideView(MyComp, new ViewMetadata({
                                     template: '<p><child-cmp ref-superAlice></child-cmp></p>',
                                     directives: [ChildComp]
@@ -709,7 +709,7 @@ function declareTests(isJit: boolean) {
       describe('variables', () => {
         it('should allow to use variables in a for loop',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(
                     MyComp, new ViewMetadata({
                       template:
@@ -733,7 +733,7 @@ function declareTests(isJit: boolean) {
 
         it("should use ChangeDetectorRef to manually request a check",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                       tcb.overrideView(MyComp, new ViewMetadata({
                                          template: '<push-cmp-with-ref #cmp></push-cmp-with-ref>',
@@ -760,7 +760,7 @@ function declareTests(isJit: boolean) {
 
         it("should be checked when its bindings got updated",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                       tcb.overrideView(MyComp, new ViewMetadata({
                                          template: '<push-cmp [prop]="ctxProp" #cmp></push-cmp>',
@@ -798,7 +798,7 @@ function declareTests(isJit: boolean) {
 
                var cmpEl = fixture.debugElement.children[0];
                var cmp: PushCmpWithHostEvent = cmpEl.inject(PushCmpWithHostEvent);
-               cmp.ctxCallback = (_) => fixture.destroy();
+               cmp.ctxCallback = (_: any /** TODO #9100 */) => fixture.destroy();
 
                expect(() => cmpEl.triggerEventHandler('click', <Event>{})).not.toThrow();
              })));
@@ -806,7 +806,7 @@ function declareTests(isJit: boolean) {
 
         it("should be checked when an event is fired",
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                       tcb.overrideView(MyComp, new ViewMetadata({
                                          template: '<push-cmp [prop]="ctxProp" #cmp></push-cmp>',
@@ -847,7 +847,7 @@ function declareTests(isJit: boolean) {
 
         it('should not affect updating properties on the component',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                       tcb.overrideView(
                              MyComp, new ViewMetadata({
                                template:
@@ -903,7 +903,7 @@ function declareTests(isJit: boolean) {
       it('should create a component that injects an @Host',
          inject([TestComponentBuilder, AsyncTestCompleter],
                 (tcb: TestComponentBuilder,
-                 async) => {tcb.overrideView(MyComp, new ViewMetadata({
+                 async: any /** TODO #9100 */) => {tcb.overrideView(MyComp, new ViewMetadata({
                                                template: `
             <some-directive>
               <p>
@@ -926,7 +926,7 @@ function declareTests(isJit: boolean) {
                                 })}));
 
       it('should create a component that injects an @Host through viewcontainer directive',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: `
             <some-directive>
@@ -951,7 +951,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support events via EventEmitter on regular elements',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<div emitter listener></div>',
                               directives: [DirectiveEmittingEvent, DirectiveListeningEvent]
@@ -985,7 +985,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support events via EventEmitter on template elements',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: '<template emitter listener (event)="ctxProp=$event"></template>',
@@ -1015,7 +1015,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support [()] syntax',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<div [(control)]="ctxProp" two-way></div>',
                               directives: [DirectiveWithTwoWayBinding]
@@ -1041,7 +1041,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support render events',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata(
@@ -1069,7 +1069,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support render global events',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata(
@@ -1096,7 +1096,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support updating host element via hostAttributes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<div update-host-attributes></div>',
                               directives: [DirectiveUpdatingHostAttributes]
@@ -1115,7 +1115,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support updating host element via hostProperties',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<div update-host-properties></div>',
                               directives: [DirectiveUpdatingHostProperties]
@@ -1140,7 +1140,7 @@ function declareTests(isJit: boolean) {
       if (getDOM().supportsDOMEvents()) {
         it('should support preventing default on render events',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(
                     MyComp, new ViewMetadata({
                       template:
@@ -1171,7 +1171,7 @@ function declareTests(isJit: boolean) {
       }
 
       it('should support render global events from multiple directives',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: '<div *ngIf="ctxBoolProp" listener listenerother></div>',
@@ -1215,7 +1215,7 @@ function declareTests(isJit: boolean) {
       describe('dynamic ViewContainers', () => {
         it('should allow to create a ViewContainerRef at any bound location',
            inject([TestComponentBuilder, AsyncTestCompleter, ComponentResolver],
-                  (tcb: TestComponentBuilder, async, compiler) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */, compiler: any /** TODO #9100 */) => {
                     tcb.overrideView(MyComp, new ViewMetadata({
                                        template: '<div><dynamic-vp #dynamic></dynamic-vp></div>',
                                        directives: [DynamicViewport]
@@ -1237,7 +1237,7 @@ function declareTests(isJit: boolean) {
       });
 
       it('should support static attributes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp,
                   new ViewMetadata(
@@ -1257,7 +1257,7 @@ function declareTests(isJit: boolean) {
 
     describe("dependency injection", () => {
       it("should support bindings",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: `
@@ -1278,7 +1278,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it("should support viewProviders",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(DirectiveProvidingInjectableInView, new ViewMetadata({
                               template: `
               <directive-consuming-injectable #consuming>
@@ -1296,7 +1296,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it("should support unbounded lookup",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: `
             <directive-providing-injectable>
@@ -1326,7 +1326,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it("should support the event-bus scenario",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: `
             <grand-parent-providing-event-bus>
@@ -1362,7 +1362,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it("should instantiate bindings lazily",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: `
@@ -1391,7 +1391,7 @@ function declareTests(isJit: boolean) {
 
     describe("corner cases", () => {
       it('should remove script tags from templates',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: `
             <script>alert("Ooops");</script>
@@ -1409,7 +1409,7 @@ function declareTests(isJit: boolean) {
 
     describe("error handling", () => {
       it('should report a meaningful error when a directive is missing annotation',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb = tcb.overrideView(
                MyComp,
                new ViewMetadata({template: '', directives: [SomeDirectiveMissingAnnotation]}));
@@ -1423,7 +1423,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should report a meaningful error when a component is missing view annotation',
-         inject([TestComponentBuilder], (tcb: TestComponentBuilder) => {
+         inject([TestComponentBuilder], (tcb: TestComponentBuilder): any /** TODO #9100 */ => {
            try {
              tcb.createAsync(ComponentWithoutView);
            } catch (e) {
@@ -1433,7 +1433,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should report a meaningful error when a directive is null',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
            tcb = tcb.overrideView(MyComp, new ViewMetadata({directives: [[null]], template: ''}));
 
@@ -1446,7 +1446,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should provide an error context when an error happens in DI',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
            tcb =
                tcb.overrideView(MyComp, new ViewMetadata({
@@ -1464,7 +1464,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should provide an error context when an error happens in change detection',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
            tcb = tcb.overrideView(
                MyComp, new ViewMetadata({template: `<input [value]="one.two.three" #local>`}));
@@ -1488,7 +1488,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should provide an error context when an error happens in change detection (text node)',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
            tcb = tcb.overrideView(MyComp,
                                   new ViewMetadata({template: `<div>{{one.two.three}}</div>`}));
@@ -1540,9 +1540,9 @@ function declareTests(isJit: boolean) {
       if (!IS_DART) {
         it('should report a meaningful error when a directive is undefined',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
 
-             var undefinedValue;
+             var undefinedValue: any /** TODO #9100 */;
 
              tcb = tcb.overrideView(MyComp,
                                     new ViewMetadata({directives: [undefinedValue], template: ''}));
@@ -1558,7 +1558,7 @@ function declareTests(isJit: boolean) {
 
       it('should specify a location of an error that happened during change detection (text)',
          inject([TestComponentBuilder, AsyncTestCompleter],
-                (tcb: TestComponentBuilder, async) => {
+                (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.overrideView(MyComp, new ViewMetadata({template: '<div>{{a.b}}</div>'}))
 
@@ -1572,7 +1572,7 @@ function declareTests(isJit: boolean) {
       it('should specify a location of an error that happened during change detection (element property)',
          inject(
              [TestComponentBuilder, AsyncTestCompleter],
-             (tcb: TestComponentBuilder, async) => {
+             (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                  tcb.overrideView(MyComp, new ViewMetadata({template: '<div [title]="a.b"></div>'}))
 
@@ -1584,7 +1584,7 @@ function declareTests(isJit: boolean) {
 
       it('should specify a location of an error that happened during change detection (directive property)',
          inject([TestComponentBuilder, AsyncTestCompleter],
-                (tcb: TestComponentBuilder, async) => {
+                (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
                     tcb.overrideView(MyComp, new ViewMetadata({
                                        template: '<child-cmp [title]="a.b"></child-cmp>',
@@ -1600,7 +1600,7 @@ function declareTests(isJit: boolean) {
     });
 
     it('should support imperative views',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MyComp, new ViewMetadata({
                             template: '<simple-imp-cmp></simple-imp-cmp>',
                             directives: [SimpleImperativeViewComponent]
@@ -1614,7 +1614,7 @@ function declareTests(isJit: boolean) {
 
     it('should support moving embedded views around',
        inject([TestComponentBuilder, AsyncTestCompleter, ANCHOR_ELEMENT],
-              (tcb: TestComponentBuilder, async, anchorElement) => {
+              (tcb: TestComponentBuilder, async: any /** TODO #9100 */, anchorElement: any /** TODO #9100 */) => {
                 tcb.overrideView(MyComp, new ViewMetadata({
                                    template: '<div><div *someImpvp="ctxBoolProp">hello</div></div>',
                                    directives: [SomeImperativeViewport]
@@ -1641,7 +1641,7 @@ function declareTests(isJit: boolean) {
       if (!IS_DART) {
         it('should throw on bindings to unknown properties',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb =
                  tcb.overrideView(MyComp,
                                   new ViewMetadata({template: '<div unknown="{{ctxProp}}"></div>'}))
@@ -1656,7 +1656,7 @@ function declareTests(isJit: boolean) {
 
         it('should not throw for property binding to a non-existing property when there is a matching directive property',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(
                     MyComp,
                     new ViewMetadata(
@@ -1667,7 +1667,7 @@ function declareTests(isJit: boolean) {
       }
 
       it('should not be created when there is a directive with the same property',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<span [title]="ctxProp"></span>',
                               directives: [DirectiveWithTitle]
@@ -1686,7 +1686,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should work when a directive uses hostProperty to update the DOM element',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<span [title]="ctxProp"></span>',
                               directives: [DirectiveWithTitleAndHostProperty]
@@ -1710,7 +1710,7 @@ function declareTests(isJit: boolean) {
           () => [{provide: CompilerConfig, useValue: new CompilerConfig(true, true, isJit)}]);
 
       it('should reflect property values as attributes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var tpl = '<div>' +
                      '<div my-dir [elprop]="ctxProp"></div>' +
                      '</div>';
@@ -1728,7 +1728,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should reflect property values on template comments',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var tpl = '<template [ngIf]="ctxBoolProp"></template>';
            tcb.overrideView(MyComp, new ViewMetadata({template: tpl, directives: [NgIf]}))
 
@@ -1746,7 +1746,7 @@ function declareTests(isJit: boolean) {
 
     describe('property decorators', () => {
       it('should support property decorators',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp, new ViewMetadata({
                     template: '<with-prop-decorators elProp="aaa"></with-prop-decorators>',
@@ -1762,7 +1762,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support host binding decorators',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<with-prop-decorators></with-prop-decorators>',
                               directives: [DirectiveWithPropDecorators]
@@ -1803,7 +1803,7 @@ function declareTests(isJit: boolean) {
 
         it('should support host listener decorators',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(MyComp, new ViewMetadata({
                                 template: '<with-prop-decorators></with-prop-decorators>',
                                 directives: [DirectiveWithPropDecorators]
@@ -1822,7 +1822,7 @@ function declareTests(isJit: boolean) {
       }
 
       it('should support defining views in the component decorator',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp, new ViewMetadata({
                               template: '<component-with-template></component-with-template>',
                               directives: [ComponentWithTemplate]
@@ -1842,7 +1842,7 @@ function declareTests(isJit: boolean) {
       describe('svg', () => {
         it('should support svg elements',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(MyComp,
                               new ViewMetadata({template: '<svg><use xlink:href="Port" /></svg>'}))
                  .createAsync(MyComp)
@@ -1874,7 +1874,7 @@ function declareTests(isJit: boolean) {
 
         it('should support attributes with namespace',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(SomeCmp, new ViewMetadata({template: '<svg:use xlink:href="#id" />'}))
                  .createAsync(SomeCmp)
                  .then((fixture) => {
@@ -1887,7 +1887,7 @@ function declareTests(isJit: boolean) {
 
         it('should support binding to attributes with namespace',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
-                                                               async) => {
+                                                               async: any /** TODO #9100 */) => {
              tcb.overrideView(SomeCmp,
                               new ViewMetadata({template: '<svg:use [attr.xlink:href]="value" />'}))
                  .createAsync(SomeCmp)
@@ -1924,7 +1924,7 @@ class MyService {
 @Component({selector: 'simple-imp-cmp', template: ''})
 @Injectable()
 class SimpleImperativeViewComponent {
-  done;
+  done: any /** TODO #9100 */;
 
   constructor(self: ElementRef, renderer: Renderer) {
     var hostElement = self.nativeElement;
@@ -1980,7 +1980,7 @@ class EventCmp {
 @Injectable()
 class PushCmp {
   numberOfChecks: number;
-  prop;
+  prop: any /** TODO #9100 */;
 
   constructor() { this.numberOfChecks = 0; }
 
@@ -2002,7 +2002,7 @@ class PushCmp {
 class PushCmpWithRef {
   numberOfChecks: number;
   ref: ChangeDetectorRef;
-  prop;
+  prop: any /** TODO #9100 */;
 
   constructor(ref: ChangeDetectorRef) {
     this.numberOfChecks = 0;
@@ -2024,7 +2024,7 @@ class PushCmpWithRef {
   template: ''
 })
 class PushCmpWithHostEvent {
-  ctxCallback: Function = (_) => {};
+  ctxCallback: Function = (_: any /** TODO #9100 */) => {};
 }
 
 @Component({
@@ -2049,7 +2049,7 @@ class PushCmpWithAsyncPipe {
     return this.promise;
   }
 
-  resolve(value) { this.completer.resolve(value); }
+  resolve(value: any /** TODO #9100 */) { this.completer.resolve(value); }
 }
 
 @Component({selector: 'my-comp', directives: []})
@@ -2142,7 +2142,7 @@ class SomeViewport {
 @Pipe({name: 'double'})
 class DoublePipe implements PipeTransform, OnDestroy {
   ngOnDestroy() {}
-  transform(value) { return `${value}${value}`; }
+  transform(value: any /** TODO #9100 */) { return `${value}${value}`; }
 }
 
 @Directive({selector: '[emitter]', outputs: ['event']})
@@ -2215,13 +2215,13 @@ class DirectiveListeningDomEventOther {
 @Directive({selector: '[listenerprevent]', host: {'(click)': 'onEvent($event)'}})
 @Injectable()
 class DirectiveListeningDomEventPrevent {
-  onEvent(event) { return false; }
+  onEvent(event: any /** TODO #9100 */) { return false; }
 }
 
 @Directive({selector: '[listenernoprevent]', host: {'(click)': 'onEvent($event)'}})
 @Injectable()
 class DirectiveListeningDomEventNoPrevent {
-  onEvent(event) { return true; }
+  onEvent(event: any /** TODO #9100 */) { return true; }
 }
 
 @Directive({selector: '[id]', inputs: ['id']})
@@ -2240,9 +2240,9 @@ class EventDir {
 @Directive({selector: '[static]'})
 @Injectable()
 class NeedsAttribute {
-  typeAttribute;
-  staticAttribute;
-  fooAttribute;
+  typeAttribute: any /** TODO #9100 */;
+  staticAttribute: any /** TODO #9100 */;
+  fooAttribute: any /** TODO #9100 */;
   constructor(@Attribute('type') typeAttribute: String,
               @Attribute('static') staticAttribute: String,
               @Attribute('foo') fooAttribute: String) {
@@ -2314,9 +2314,9 @@ class ToolbarComponent {
 @Injectable()
 class DirectiveWithTwoWayBinding {
   controlChange = new EventEmitter();
-  control = null;
+  control: any /** TODO #9100 */ = null;
 
-  triggerChange(value) { ObservableWrapper.callEmit(this.controlChange, value); }
+  triggerChange(value: any /** TODO #9100 */) { ObservableWrapper.callEmit(this.controlChange, value); }
 }
 
 @Injectable()
@@ -2373,9 +2373,9 @@ class DirectiveProvidingInjectableInHostAndView {
 @Component({selector: 'directive-consuming-injectable', template: ''})
 @Injectable()
 class DirectiveConsumingInjectable {
-  injectable;
+  injectable: any /** TODO #9100 */;
 
-  constructor(@Host() @Inject(InjectableService) injectable) { this.injectable = injectable; }
+  constructor(@Host() @Inject(InjectableService) injectable: any /** TODO #9100 */) { this.injectable = injectable; }
 }
 
 
@@ -2383,13 +2383,13 @@ class DirectiveConsumingInjectable {
 @Component({selector: 'directive-containing-directive-consuming-an-injectable'})
 @Injectable()
 class DirectiveContainingDirectiveConsumingAnInjectable {
-  directive;
+  directive: any /** TODO #9100 */;
 }
 
 @Component({selector: 'directive-consuming-injectable-unbounded', template: ''})
 @Injectable()
 class DirectiveConsumingInjectableUnbounded {
-  injectable;
+  injectable: any /** TODO #9100 */;
 
   constructor(injectable: InjectableService,
               @SkipSelf() parent: DirectiveContainingDirectiveConsumingAnInjectable) {
@@ -2422,7 +2422,7 @@ class GrandParentProvidingEventBus {
   constructor(bus: EventBus) { this.bus = bus; }
 }
 
-function createParentBus(peb) {
+function createParentBus(peb: any /** TODO #9100 */) {
   return new EventBus(peb, "parent");
 }
 
@@ -2455,9 +2455,9 @@ class ChildConsumingEventBus {
 @Injectable()
 class SomeImperativeViewport {
   view: EmbeddedViewRef<Object>;
-  anchor;
+  anchor: any /** TODO #9100 */;
   constructor(public vc: ViewContainerRef, public templateRef: TemplateRef<Object>,
-              @Inject(ANCHOR_ELEMENT) anchor) {
+              @Inject(ANCHOR_ELEMENT) anchor: any /** TODO #9100 */) {
     this.view = null;
     this.anchor = anchor;
   }
@@ -2516,18 +2516,18 @@ class ComponentWithTemplate {
 
 @Directive({selector: 'with-prop-decorators'})
 class DirectiveWithPropDecorators {
-  target;
+  target: any /** TODO #9100 */;
 
   @Input('elProp') dirProp: string;
   @Output('elEvent') event = new EventEmitter();
 
   @HostBinding("attr.my-attr") myAttr: string;
   @HostListener("click", ["$event.target"])
-  onClick(target) {
+  onClick(target: any /** TODO #9100 */) {
     this.target = target;
   }
 
-  fireEvent(msg) { ObservableWrapper.callEmit(this.event, msg); }
+  fireEvent(msg: any /** TODO #9100 */) { ObservableWrapper.callEmit(this.event, msg); }
 }
 
 @Component({selector: 'some-cmp'})
diff --git a/modules/@angular/core/test/linker/projection_integration_spec.ts b/modules/@angular/core/test/linker/projection_integration_spec.ts
index 9a2a4dbab6..711bde9000 100644
--- a/modules/@angular/core/test/linker/projection_integration_spec.ts
+++ b/modules/@angular/core/test/linker/projection_integration_spec.ts
@@ -35,7 +35,7 @@ import {getAllDebugNodes} from '@angular/core/src/debug/debug_node';
 export function main() {
   describe('projection', () => {
     it('should support simple components',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<simple>' +
                                           '<div>A</div>' +
@@ -50,7 +50,7 @@ export function main() {
        }));
 
     it('should support simple components with text interpolation as direct children',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '{{\'START(\'}}<simple>' +
                                           '{{text}}' +
@@ -68,7 +68,7 @@ export function main() {
        }));
 
     it('should support projecting text interpolation to a non bound element',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 Simple,
                 new ViewMetadata(
@@ -88,7 +88,7 @@ export function main() {
 
 
     it('should support projecting text interpolation to a non bound element with other bound elements after it',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 Simple, new ViewMetadata({
                   template:
@@ -109,7 +109,7 @@ export function main() {
        }));
 
     it('should project content components',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 Simple,
                 new ViewMetadata(
@@ -129,7 +129,7 @@ export function main() {
        }));
 
     it('should not show the light dom even if there is no content tag',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp,
                           new ViewMetadata({template: '<empty>A</empty>', directives: [Empty]}))
              .createAsync(MainComp)
@@ -141,7 +141,7 @@ export function main() {
        }));
 
     it('should support multiple content tags',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
                                           '<div>B</div>' +
@@ -159,7 +159,7 @@ export function main() {
        }));
 
     it('should redistribute only direct children',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
                                           '<div>B<div class="left">A</div></div>' +
@@ -176,7 +176,7 @@ export function main() {
        }));
 
     it("should redistribute direct child viewcontainers when the light dom changes",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<multiple-content-tags>' +
                                           '<template manual class="left"><div>A1</div></template>' +
@@ -204,7 +204,7 @@ export function main() {
        }));
 
     it("should support nested components",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<outer-with-indirect-nested>' +
                                           '<div>A</div>' +
@@ -221,7 +221,7 @@ export function main() {
        }));
 
     it("should support nesting with content being direct child of a nested component",
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<outer>' +
                                           '<template manual class="left"><div>A</div></template>' +
@@ -246,7 +246,7 @@ export function main() {
        }));
 
     it('should redistribute when the shadow dom changes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<conditional-content>' +
                                           '<div class="left">A</div>' +
@@ -278,7 +278,7 @@ export function main() {
     // important as we are removing the ng-content element during compilation,
     // which could skrew up text node indices.
     it('should support text nodes after content tags',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideView(
                 MainComp,
@@ -299,7 +299,7 @@ export function main() {
     // important as we are moving style tags around during compilation,
     // which could skrew up text node indices.
     it('should support text nodes after style tags',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
 
          tcb.overrideView(
                 MainComp,
@@ -316,7 +316,7 @@ export function main() {
        }));
 
     it('should support moving non projected light dom around',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<empty>' +
                                           '  <template manual><div>A</div></template>' +
@@ -326,7 +326,7 @@ export function main() {
                           }))
              .createAsync(MainComp)
              .then((main) => {
-               var sourceDirective;
+               var sourceDirective: any /** TODO #9100 */;
 
                // We can't use the child nodes to get a hold of this because it's not in the dom at
                // all.
@@ -349,7 +349,7 @@ export function main() {
        }));
 
     it('should support moving projected light dom around',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<simple><template manual><div>A</div></template></simple>' +
                                           'START(<div project></div>)END',
@@ -373,7 +373,7 @@ export function main() {
        }));
 
     it('should support moving ng-content around',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 MainComp, new ViewMetadata({
                   template: '<conditional-content>' +
@@ -411,7 +411,7 @@ export function main() {
     // is still important as we are merging proto views independent of
     // the presence of ng-content elements!
     it('should still allow to implement a recursive trees',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp,
                           new ViewMetadata({template: '<tree></tree>', directives: [Tree]}))
              .createAsync(MainComp)
@@ -433,7 +433,7 @@ export function main() {
     // is still important as we are merging proto views independent of
     // the presence of ng-content elements!
     it('should still allow to implement a recursive trees via multiple components',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp,
                           new ViewMetadata({template: '<tree></tree>', directives: [Tree]}))
              .overrideView(Tree, new ViewMetadata({
@@ -468,7 +468,7 @@ export function main() {
 
     if (getDOM().supportsNativeShadowDOM()) {
       it('should support native content projection and isolate styles per component',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MainComp, new ViewMetadata({
                               template: '<simple-native1><div>A</div></simple-native1>' +
                                             '<simple-native2><div>B</div></simple-native2>',
@@ -487,7 +487,7 @@ export function main() {
 
     if (getDOM().supportsDOMEvents()) {
       it('should support non emulated styles',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MainComp, new ViewMetadata({
                               template: '<div class="redStyle"></div>',
                               styles: ['.redStyle { color: red}'],
@@ -508,7 +508,7 @@ export function main() {
          }));
 
       it('should support emulated style encapsulation',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MainComp, new ViewMetadata({
                               template: '<div></div>',
                               styles: ['div { color: red}'],
@@ -528,7 +528,7 @@ export function main() {
     }
 
     it('should support nested conditionals that contain ng-contents',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: `<conditional-text>a</conditional-text>`,
                             directives: [ConditionalTextComponent]
@@ -552,7 +552,7 @@ export function main() {
        }));
 
     it('should allow to switch the order of nested components via ng-content',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: `<cmp-a><cmp-b></cmp-b></cmp-a>`,
                             directives: [CmpA, CmpB],
@@ -568,7 +568,7 @@ export function main() {
        }));
 
     it('should create nested components in the right order',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: `<cmp-a1></cmp-a1><cmp-a2></cmp-a2>`,
                             directives: [CmpA1, CmpA2],
@@ -584,7 +584,7 @@ export function main() {
        }));
 
     it('should project filled view containers into a view container',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MainComp, new ViewMetadata({
                             template: '<conditional-content>' +
                                           '<div class="left">A</div>' +
diff --git a/modules/@angular/core/test/linker/query_integration_spec.ts b/modules/@angular/core/test/linker/query_integration_spec.ts
index e13990707d..7886cb23bb 100644
--- a/modules/@angular/core/test/linker/query_integration_spec.ts
+++ b/modules/@angular/core/test/linker/query_integration_spec.ts
@@ -39,7 +39,7 @@ export function main() {
   describe('Query API', () => {
     describe("querying by directive type", () => {
       it('should contain all direct child directives in the light dom (constructor)',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div text="1"></div>' +
                           '<needs-query text="2"><div text="3">' +
                           '<div text="too-deep"></div>' +
@@ -58,7 +58,7 @@ export function main() {
          }));
 
       it('should contain all direct child directives in the content dom',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-content-children #q><div text="foo"></div></needs-content-children>';
 
@@ -79,7 +79,7 @@ export function main() {
          }));
 
       it('should contain the first content child',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-content-child #q><div *ngIf="shouldShow" text="foo"></div></needs-content-child>';
 
@@ -109,7 +109,7 @@ export function main() {
          }));
 
       it('should contain the first view child',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-child #q></needs-view-child>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -136,7 +136,7 @@ export function main() {
          }));
 
       it('should set static view and content children already after the constructor call',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-static-content-view-child #q><div text="contentFoo"></div></needs-static-content-view-child>';
 
@@ -158,7 +158,7 @@ export function main() {
          }));
 
       it('should contain the first view child accross embedded views',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-child #q></needs-view-child>';
            tcb.overrideTemplate(MyComp0, template)
                .overrideTemplate(
@@ -190,7 +190,7 @@ export function main() {
          }));
 
       it('should contain all directives in the light dom when descendants flag is used',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div text="1"></div>' +
                           '<needs-query-desc text="2"><div text="3">' +
                           '<div text="4"></div>' +
@@ -208,7 +208,7 @@ export function main() {
          }));
 
       it('should contain all directives in the light dom',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<div text="1"></div>' +
                           '<needs-query text="2"><div text="3"></div></needs-query>' +
                           '<div text="4"></div>';
@@ -224,7 +224,7 @@ export function main() {
          }));
 
       it('should reflect dynamically inserted directives',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<div text="1"></div>' +
                '<needs-query text="2"><div *ngIf="shouldShow" [text]="\'3\'"></div></needs-query>' +
@@ -246,7 +246,7 @@ export function main() {
          }));
 
       it('should be cleanly destroyed when a query crosses view boundaries',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<div text="1"></div>' +
                '<needs-query text="2"><div *ngIf="shouldShow" [text]="\'3\'"></div></needs-query>' +
@@ -264,7 +264,7 @@ export function main() {
          }));
 
       it('should reflect moved directives',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<div text="1"></div>' +
                '<needs-query text="2"><div *ngFor="let  i of list" [text]="i"></div></needs-query>' +
@@ -286,7 +286,7 @@ export function main() {
          }));
 
       it('should throw with descriptive error when query selectors are not present',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideTemplate(MyCompBroken0, '<has-null-query-condition></has-null-query-condition>')
                .createAsync(MyCompBroken0)
                .catch((e) => {
@@ -299,7 +299,7 @@ export function main() {
 
     describe('query for TemplateRef', () => {
       it('should find TemplateRefs in the light and shadow dom',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-tpl><template><div>light</div></template></needs-tpl>';
            tcb.overrideTemplate(MyComp0, template)
                .createAsync(MyComp0)
@@ -317,7 +317,7 @@ export function main() {
          }));
 
       it('should find named TemplateRefs',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-named-tpl><template #tpl><div>light</div></template></needs-named-tpl>';
            tcb.overrideTemplate(MyComp0, template)
@@ -337,7 +337,7 @@ export function main() {
 
     describe('read a different token', () => {
       it('should contain all content children',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-content-children-read #q text="ca"><div #q text="cb"></div></needs-content-children-read>';
 
@@ -356,7 +356,7 @@ export function main() {
          }));
 
       it('should contain the first content child',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-content-child-read><div #q text="ca"></div></needs-content-child-read>';
 
@@ -374,7 +374,7 @@ export function main() {
          }));
 
       it('should contain the first view child',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-child-read></needs-view-child-read>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -391,7 +391,7 @@ export function main() {
          }));
 
       it('should contain all child directives in the view',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-children-read></needs-view-children-read>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -409,7 +409,7 @@ export function main() {
          }));
 
       it('should support reading a ViewContainer',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-viewcontainer-read><template>hello</template></needs-viewcontainer-read>';
 
@@ -430,7 +430,7 @@ export function main() {
 
     describe("changes", () => {
       it('should notify query on change',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query #q>' +
                           '<div text="1"></div>' +
                           '<div *ngIf="shouldShow" text="2"></div>' +
@@ -454,7 +454,7 @@ export function main() {
          }));
 
       it("should notify child's query before notifying parent's query",
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query-desc #q1>' +
                           '<needs-query-desc #q2>' +
                           '<div text="1"></div>' +
@@ -480,7 +480,7 @@ export function main() {
          }));
 
       it('should correctly clean-up when destroyed together with the directives it is querying',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query #q *ngIf="shouldShow"><div text="foo"></div></needs-query>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -510,7 +510,7 @@ export function main() {
 
     describe("querying by var binding", () => {
       it('should contain all the child directives in the light dom with the given var binding',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-query-by-ref-binding #q>' +
                '<div *ngFor="let item of list" [text]="item" #textLabel="textDir"></div>' +
@@ -533,7 +533,7 @@ export function main() {
          }));
 
       it('should support querying by multiple var bindings',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query-by-ref-bindings #q>' +
                           '<div text="one" #textLabel1="textDir"></div>' +
                           '<div text="two" #textLabel2="textDir"></div>' +
@@ -553,7 +553,7 @@ export function main() {
          }));
 
       it('should support dynamically inserted directives',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template =
                '<needs-query-by-ref-binding #q>' +
                '<div *ngFor="let item of list" [text]="item" #textLabel="textDir"></div>' +
@@ -579,7 +579,7 @@ export function main() {
          }));
 
       it('should contain all the elements in the light dom with the given var binding',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query-by-ref-binding #q>' +
                           '<div template="ngFor: let item of list">' +
                           '<div #textLabel>{{item}}</div>' +
@@ -603,7 +603,7 @@ export function main() {
          }));
 
       it('should contain all the elements in the light dom even if they get projected',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-query-and-project #q>' +
                           '<div text="hello"></div><div text="world"></div>' +
                           '</needs-query-and-project>';
@@ -620,7 +620,7 @@ export function main() {
          }));
 
       it('should support querying the view by using a view query',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-by-ref-binding #q></needs-view-query-by-ref-binding>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -636,7 +636,7 @@ export function main() {
          }));
 
       it('should contain all child directives in the view dom',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-children #q></needs-view-children>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -659,7 +659,7 @@ export function main() {
 
     describe("querying in the view", () => {
       it('should contain all the elements in the view with that have the given directive',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query #q><div text="ignoreme"></div></needs-view-query>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -676,7 +676,7 @@ export function main() {
          }));
 
       it('should not include directive present on the host element',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query #q text="self"></needs-view-query>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -693,7 +693,7 @@ export function main() {
          }));
 
       it('should reflect changes in the component',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-if #q></needs-view-query-if>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -716,7 +716,7 @@ export function main() {
          }));
 
       it('should not be affected by other changes in the component',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-nested-if #q></needs-view-query-nested-if>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -741,7 +741,7 @@ export function main() {
 
 
       it('should maintain directives in pre-order depth-first DOM order after dynamic insertion',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-order #q></needs-view-query-order>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -764,7 +764,7 @@ export function main() {
          }));
 
       it('should maintain directives in pre-order depth-first DOM order after dynamic insertion',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-order-with-p #q></needs-view-query-order-with-p>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -788,7 +788,7 @@ export function main() {
          }));
 
       it('should handle long ngFor cycles',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-view-query-order #q></needs-view-query-order>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -810,7 +810,7 @@ export function main() {
          }));
 
       it('should support more than three queries',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var template = '<needs-four-queries #q><div text="1"></div></needs-four-queries>';
 
            tcb.overrideTemplate(MyComp0, template)
@@ -866,7 +866,7 @@ class NeedsContentChild implements AfterContentInit, AfterContentChecked {
   }
 
   get child() { return this._child; }
-  logs = [];
+  logs: any[] /** TODO #9100 */ = [];
 
   ngAfterContentInit() { this.logs.push(["init", isPresent(this.child) ? this.child.text : null]); }
 
@@ -895,7 +895,7 @@ class NeedsViewChild implements AfterViewInit,
   }
 
   get child() { return this._child; }
-  logs = [];
+  logs: any[] /** TODO #9100 */ = [];
 
   ngAfterViewInit() { this.logs.push(["init", isPresent(this.child) ? this.child.text : null]); }
 
@@ -1134,7 +1134,7 @@ class NeedsViewContainerWithRead {
 
 @Component({selector: 'has-null-query-condition', template: '<div></div>'})
 class HasNullQueryCondition {
-  @ContentChildren(null) errorTrigger;
+  @ContentChildren(null) errorTrigger: any /** TODO #9100 */;
 }
 
 @Component({
@@ -1174,7 +1174,7 @@ class HasNullQueryCondition {
 @Injectable()
 class MyComp0 {
   shouldShow: boolean;
-  list;
+  list: any /** TODO #9100 */;
   constructor() {
     this.shouldShow = false;
     this.list = ['1d', '2d', '3d'];
diff --git a/modules/@angular/core/test/linker/query_list_spec.ts b/modules/@angular/core/test/linker/query_list_spec.ts
index 0c6784b09d..d02a480153 100644
--- a/modules/@angular/core/test/linker/query_list_spec.ts
+++ b/modules/@angular/core/test/linker/query_list_spec.ts
@@ -32,7 +32,7 @@ export function main() {
       log = '';
     });
 
-    function logAppend(item) { log += (log.length == 0 ? '' : ', ') + item; }
+    function logAppend(item: any /** TODO #9100 */) { log += (log.length == 0 ? '' : ', ') + item; }
 
     it('should support resetting and iterating over the new objects', () => {
       queryList.reset(['one']);
@@ -61,17 +61,17 @@ export function main() {
     if (!IS_DART) {
       it('should support filter', () => {
         queryList.reset(['one', 'two']);
-        expect((<_JsQueryList>queryList).filter((x) => x == "one")).toEqual(['one']);
+        expect((<_JsQueryList>queryList).filter((x: any /** TODO #9100 */) => x == "one")).toEqual(['one']);
       });
 
       it('should support reduce', () => {
         queryList.reset(["one", "two"]);
-        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, "start:")).toEqual("start:onetwo");
+        expect((<_JsQueryList>queryList).reduce((a: any /** TODO #9100 */, x: any /** TODO #9100 */) => a + x, "start:")).toEqual("start:onetwo");
       });
 
       it('should support toArray', () => {
         queryList.reset(["one", "two"]);
-        expect((<_JsQueryList>queryList).reduce((a, x) => a + x, "start:")).toEqual("start:onetwo");
+        expect((<_JsQueryList>queryList).reduce((a: any /** TODO #9100 */, x: any /** TODO #9100 */) => a + x, "start:")).toEqual("start:onetwo");
       });
 
       it('should support toArray', () => {
@@ -111,7 +111,7 @@ export function main() {
            }));
 
         it('should provides query list as an argument', fakeAsync(() => {
-             var recorded;
+             var recorded: any /** TODO #9100 */;
              ObservableWrapper.subscribe(queryList.changes, (v: any) => { recorded = v; });
 
              queryList.reset(["one"]);
diff --git a/modules/@angular/core/test/linker/reflector_component_resolver_spec.ts b/modules/@angular/core/test/linker/reflector_component_resolver_spec.ts
index 4b68a32423..2f4328ef6c 100644
--- a/modules/@angular/core/test/linker/reflector_component_resolver_spec.ts
+++ b/modules/@angular/core/test/linker/reflector_component_resolver_spec.ts
@@ -23,17 +23,17 @@ import {ComponentFactory} from '@angular/core/src/linker/component_factory';
 
 export function main() {
   describe('Compiler', () => {
-    var someCompFactory;
+    var someCompFactory: any /** TODO #9100 */;
 
     beforeEachProviders(() => [{provide: ComponentResolver, useClass: ReflectorComponentResolver}]);
 
-    beforeEach(inject([ComponentResolver], (_compiler) => {
+    beforeEach(inject([ComponentResolver], (_compiler: any /** TODO #9100 */) => {
       someCompFactory = new ComponentFactory(null, null, null);
       reflector.registerType(SomeComponent, new ReflectionInfo([someCompFactory]));
     }));
 
     it('should read the template from an annotation',
-       inject([AsyncTestCompleter, ComponentResolver], (async, compiler: ComponentResolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, compiler: ComponentResolver) => {
          compiler.resolveComponent(SomeComponent)
              .then((compFactory: ComponentFactory<any>) => {
                expect(compFactory).toBe(someCompFactory);
@@ -43,7 +43,7 @@ export function main() {
        }));
 
     it('should throw when given a string',
-       inject([AsyncTestCompleter, ComponentResolver], (async, compiler: ComponentResolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, compiler: ComponentResolver) => {
          compiler.resolveComponent("someString")
              .catch((e) => {
                expect(e.message).toContain("Cannot resolve component using 'someString'.")
diff --git a/modules/@angular/core/test/linker/regression_integration_spec.ts b/modules/@angular/core/test/linker/regression_integration_spec.ts
index 42ebaeb363..c5258f3a22 100644
--- a/modules/@angular/core/test/linker/regression_integration_spec.ts
+++ b/modules/@angular/core/test/linker/regression_integration_spec.ts
@@ -54,7 +54,7 @@ function declareTests(isJit: boolean) {
       beforeEachProviders(() => [{provide: PLATFORM_PIPES, useValue: [PlatformPipe], multi: true}]);
 
       it('should overwrite them by custom pipes',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(
                   MyComp1, new ViewMetadata({template: '{{true | somePipe}}', pipes: [CustomPipe]}))
                .createAsync(MyComp1)
@@ -69,7 +69,7 @@ function declareTests(isJit: boolean) {
     describe('expressions', () => {
 
       it('should evaluate conditional and boolean operators with right precedence - #8244',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp1,
                             new ViewMetadata({template: `{{'red' + (true ? ' border' : '')}}`}))
                .createAsync(MyComp1)
@@ -83,7 +83,7 @@ function declareTests(isJit: boolean) {
       if (!IS_DART) {
         it('should evaluate conditional and unary operators with right precedence - #8235',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
+                  (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
                     tcb.overrideView(MyComp1, new ViewMetadata({template: `{{!null?.length}}`}))
                         .createAsync(MyComp1)
                         .then((fixture) => {
@@ -103,7 +103,7 @@ function declareTests(isJit: boolean) {
       }
 
       it('should support providers with an OpaqueToken that contains a `.` in the name',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var token = new OpaqueToken('a.b');
            var tokenValue = 1;
            createInjector(tcb, [{provide: token, useValue: tokenValue}])
@@ -114,7 +114,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support providers with string token with a `.` in it',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var token = 'a.b';
            var tokenValue = 1;
            createInjector(tcb, [{provide: token, useValue: tokenValue}])
@@ -125,7 +125,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support providers with an anonymous function',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var token = () => true;
            var tokenValue = 1;
            createInjector(tcb, [{provide: token, useValue: tokenValue}])
@@ -136,7 +136,7 @@ function declareTests(isJit: boolean) {
          }));
 
       it('should support providers with an OpaqueToken that has a StringMap as value',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            var token1 = new OpaqueToken('someToken');
            var token2 = new OpaqueToken('someToken');
            var tokenValue1 = {'a': 1};
@@ -153,7 +153,7 @@ function declareTests(isJit: boolean) {
     });
 
     it('should allow logging a previous elements class binding via interpolation',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideTemplate(MyComp1, `<div [class.a]="true" #el>Class: {{el.className}}</div>`)
              .createAsync(MyComp1)
              .then((fixture) => {
@@ -164,7 +164,7 @@ function declareTests(isJit: boolean) {
        }));
 
     it('should support ngClass before a component and content projection inside of an ngIf',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 MyComp1, new ViewMetadata({
                   template: `A<cmp-content *ngIf="true" [ngClass]="'red'">B</cmp-content>C`,
diff --git a/modules/@angular/core/test/linker/security_integration_spec.ts b/modules/@angular/core/test/linker/security_integration_spec.ts
index 1f61f6ae79..1be6d7e564 100644
--- a/modules/@angular/core/test/linker/security_integration_spec.ts
+++ b/modules/@angular/core/test/linker/security_integration_spec.ts
@@ -47,11 +47,11 @@ class SecuredComponent {
   constructor() { this.ctxProp = 'some value'; }
 }
 
-function itAsync(msg: string, injections: Function[], f: Function);
-function itAsync(msg: string, f: (tcb: TestComponentBuilder, atc: AsyncTestCompleter) => void);
+function itAsync(msg: string, injections: Function[], f: Function): any; /** TODO #???? */
+function itAsync(msg: string, f: (tcb: TestComponentBuilder, atc: AsyncTestCompleter) => void): any; /** TODO #???? */
 function itAsync(msg: string,
                  f: Function[] | ((tcb: TestComponentBuilder, atc: AsyncTestCompleter) => void),
-                 fn?: Function) {
+                 fn?: Function): any /** TODO #???? */ {
   if (f instanceof Function) {
     it(msg, inject([TestComponentBuilder, AsyncTestCompleter], <Function>f));
   } else {
@@ -73,7 +73,7 @@ function declareTests(isJit: boolean) {
     afterEach(() => { getDOM().log = originalLog; });
 
 
-    itAsync('should disallow binding on*', (tcb: TestComponentBuilder, async) => {
+    itAsync('should disallow binding on*', (tcb: TestComponentBuilder, async: any /** TODO #???? */) => {
       let tpl = `<div [attr.onclick]="ctxProp"></div>`;
       tcb = tcb.overrideView(SecuredComponent, new ViewMetadata({template: tpl}));
       PromiseWrapper.catchError(tcb.createAsync(SecuredComponent), (e) => {
@@ -88,7 +88,7 @@ function declareTests(isJit: boolean) {
     describe('safe HTML values', function() {
       itAsync('should not escape values marked as trusted',
               [TestComponentBuilder, AsyncTestCompleter, DomSanitizationService],
-              (tcb: TestComponentBuilder, async, sanitizer: DomSanitizationService) => {
+              (tcb: TestComponentBuilder, async: any /** TODO #???? */, sanitizer: DomSanitizationService) => {
                 let tpl = `<a [href]="ctxProp">Link Title</a>`;
                 tcb.overrideView(SecuredComponent,
                                  new ViewMetadata({template: tpl, directives: []}))
@@ -107,7 +107,7 @@ function declareTests(isJit: boolean) {
 
       itAsync('should error when using the wrong trusted value',
               [TestComponentBuilder, AsyncTestCompleter, DomSanitizationService],
-              (tcb: TestComponentBuilder, async, sanitizer: DomSanitizationService) => {
+              (tcb: TestComponentBuilder, async: any /** TODO #???? */, sanitizer: DomSanitizationService) => {
                 let tpl = `<a [href]="ctxProp">Link Title</a>`;
                 tcb.overrideView(SecuredComponent,
                                  new ViewMetadata({template: tpl, directives: []}))
@@ -125,7 +125,7 @@ function declareTests(isJit: boolean) {
     });
 
     describe('sanitizing', () => {
-      itAsync('should escape unsafe attributes', (tcb: TestComponentBuilder, async) => {
+      itAsync('should escape unsafe attributes', (tcb: TestComponentBuilder, async: any /** TODO #???? */) => {
         let tpl = `<a [href]="ctxProp">Link Title</a>`;
         tcb.overrideView(SecuredComponent, new ViewMetadata({template: tpl, directives: []}))
             .createAsync(SecuredComponent)
@@ -146,7 +146,7 @@ function declareTests(isJit: boolean) {
             });
       });
 
-      itAsync('should escape unsafe style values', (tcb: TestComponentBuilder, async) => {
+      itAsync('should escape unsafe style values', (tcb: TestComponentBuilder, async: any /** TODO #???? */) => {
         let tpl = `<div [style.background]="ctxProp">Text</div>`;
         tcb.overrideView(SecuredComponent, new ViewMetadata({template: tpl, directives: []}))
             .createAsync(SecuredComponent)
@@ -169,7 +169,7 @@ function declareTests(isJit: boolean) {
             });
       });
 
-      itAsync('should escape unsafe HTML values', (tcb: TestComponentBuilder, async) => {
+      itAsync('should escape unsafe HTML values', (tcb: TestComponentBuilder, async: any /** TODO #???? */) => {
         let tpl = `<div [innerHTML]="ctxProp">Text</div>`;
         tcb.overrideView(SecuredComponent, new ViewMetadata({template: tpl, directives: []}))
             .createAsync(SecuredComponent)
diff --git a/modules/@angular/core/test/linker/view_injector_integration_spec.ts b/modules/@angular/core/test/linker/view_injector_integration_spec.ts
index 1361d477f1..10e2abe35f 100644
--- a/modules/@angular/core/test/linker/view_injector_integration_spec.ts
+++ b/modules/@angular/core/test/linker/view_injector_integration_spec.ts
@@ -137,38 +137,38 @@ class NeedsDirective {
 @Directive({selector: '[needsService]'})
 class NeedsService {
   service: any;
-  constructor(@Inject("service") service) { this.service = service; }
+  constructor(@Inject("service") service: any /** TODO #9100 */) { this.service = service; }
 }
 
 @Directive({selector: '[needsAppService]'})
 class NeedsAppService {
   service: any;
-  constructor(@Inject("appService") service) { this.service = service; }
+  constructor(@Inject("appService") service: any /** TODO #9100 */) { this.service = service; }
 }
 
 @Component({selector: '[needsHostAppService]', template: '', directives: ALL_DIRECTIVES})
 class NeedsHostAppService {
   service: any;
-  constructor(@Host() @Inject("appService") service) { this.service = service; }
+  constructor(@Host() @Inject("appService") service: any /** TODO #9100 */) { this.service = service; }
 }
 
 @Component({selector: '[needsServiceComponent]', template: ''})
 class NeedsServiceComponent {
   service: any;
-  constructor(@Inject("service") service) { this.service = service; }
+  constructor(@Inject("service") service: any /** TODO #9100 */) { this.service = service; }
 }
 
 @Directive({selector: '[needsServiceFromHost]'})
 class NeedsServiceFromHost {
   service: any;
-  constructor(@Host() @Inject("service") service) { this.service = service; }
+  constructor(@Host() @Inject("service") service: any /** TODO #9100 */) { this.service = service; }
 }
 
 @Directive({selector: '[needsAttribute]'})
 class NeedsAttribute {
-  typeAttribute;
-  titleAttribute;
-  fooAttribute;
+  typeAttribute: any /** TODO #9100 */;
+  titleAttribute: any /** TODO #9100 */;
+  fooAttribute: any /** TODO #9100 */;
   constructor(@Attribute('type') typeAttribute: String, @Attribute('title') titleAttribute: String,
               @Attribute('foo') fooAttribute: String) {
     this.typeAttribute = typeAttribute;
@@ -179,31 +179,31 @@ class NeedsAttribute {
 
 @Directive({selector: '[needsAttributeNoType]'})
 class NeedsAttributeNoType {
-  fooAttribute;
-  constructor(@Attribute('foo') fooAttribute) { this.fooAttribute = fooAttribute; }
+  fooAttribute: any /** TODO #9100 */;
+  constructor(@Attribute('foo') fooAttribute: any /** TODO #9100 */) { this.fooAttribute = fooAttribute; }
 }
 
 @Directive({selector: '[needsElementRef]'})
 class NeedsElementRef {
-  elementRef;
+  elementRef: any /** TODO #9100 */;
   constructor(ref: ElementRef) { this.elementRef = ref; }
 }
 
 @Directive({selector: '[needsViewContainerRef]'})
 class NeedsViewContainerRef {
-  viewContainer;
+  viewContainer: any /** TODO #9100 */;
   constructor(vc: ViewContainerRef) { this.viewContainer = vc; }
 }
 
 @Directive({selector: '[needsTemplateRef]'})
 class NeedsTemplateRef {
-  templateRef;
+  templateRef: any /** TODO #9100 */;
   constructor(ref: TemplateRef<Object>) { this.templateRef = ref; }
 }
 
 @Directive({selector: '[optionallyNeedsTemplateRef]'})
 class OptionallyNeedsTemplateRef {
-  templateRef;
+  templateRef: any /** TODO #9100 */;
   constructor(@Optional() ref: TemplateRef<Object>) { this.templateRef = ref; }
 }
 
@@ -244,7 +244,7 @@ class PipeNeedsChangeDetectorRef {
 @Pipe({name: 'pipeNeedsService'})
 export class PipeNeedsService implements PipeTransform {
   service: any;
-  constructor(@Inject("service") service) { this.service = service; }
+  constructor(@Inject("service") service: any /** TODO #9100 */) { this.service = service; }
   transform(value: any): any { return this; }
 }
 
@@ -289,7 +289,7 @@ export function main() {
 
     beforeEachProviders(() => [{provide: "appService", useValue: 'appService'}]);
 
-    beforeEach(inject([TestComponentBuilder], (_tcb) => { tcb = _tcb; }));
+    beforeEach(inject([TestComponentBuilder], (_tcb: any /** TODO #9100 */) => { tcb = _tcb; }));
 
     describe("injection", () => {
       it("should instantiate directives that have no dependencies", fakeAsync(() => {
@@ -336,7 +336,7 @@ export function main() {
                                      {provide: 'injectable1', useValue: 'new-injectable1'},
                                      {
                                        provide: 'injectable2',
-                                       useFactory: (val) => `${val}-injectable2`,
+                                       useFactory: (val: any /** TODO #9100 */) => `${val}-injectable2`,
                                        deps: [
                                          [
                                            new InjectMetadata('injectable1'),
@@ -352,7 +352,7 @@ export function main() {
       it("should instantiate providers that have dependencies", fakeAsync(() => {
            var providers = [
              {provide: 'injectable1', useValue: 'injectable1'},
-             {provide: 'injectable2', useFactory: (val) => `${val}-injectable2`, deps: ['injectable1']}
+             {provide: 'injectable2', useFactory: (val: any /** TODO #9100 */) => `${val}-injectable2`, deps: ['injectable1']}
            ];
            var el = createComp('<div simpleDirective></div>',
                                tcb.overrideProviders(SimpleDirective, providers));
@@ -362,7 +362,7 @@ export function main() {
       it("should instantiate viewProviders that have dependencies", fakeAsync(() => {
            var viewProviders = [
              {provide: 'injectable1', useValue: 'injectable1'},
-             {provide: 'injectable2', useFactory: (val) => `${val}-injectable2`, deps: ['injectable1']}
+             {provide: 'injectable2', useFactory: (val: any /** TODO #9100 */) => `${val}-injectable2`, deps: ['injectable1']}
            ];
 
            var el = createComp('<div simpleComponent></div>',
diff --git a/modules/@angular/core/test/metadata/decorators_spec.ts b/modules/@angular/core/test/metadata/decorators_spec.ts
index c5a062f627..1039dafaaa 100644
--- a/modules/@angular/core/test/metadata/decorators_spec.ts
+++ b/modules/@angular/core/test/metadata/decorators_spec.ts
@@ -27,7 +27,7 @@ export function main() {
 
     it('should create type in ES5', () => {
       function MyComponent(){};
-      var as;
+      var as: any /** TODO #9100 */;
       (<any>MyComponent).annotations = as = Component({}).View({});
       expect(reflector.annotations(MyComponent)).toEqual(as.annotations);
     });
diff --git a/modules/@angular/core/test/metadata/di_spec.ts b/modules/@angular/core/test/metadata/di_spec.ts
index 7c45f36723..55a1295fa8 100644
--- a/modules/@angular/core/test/metadata/di_spec.ts
+++ b/modules/@angular/core/test/metadata/di_spec.ts
@@ -25,7 +25,7 @@ import {
 export function main() {
   describe('ViewChild', () => {
     it('should support type selector',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(ViewChildTypeSelectorComponent,
                           new ViewMetadata(
                               {template: `<simple [marker]="'1'"></simple><simple [marker]="'2'"></simple>`, directives: [Simple]}))
@@ -38,7 +38,7 @@ export function main() {
              });
        }));
     it('should support string selector',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 ViewChildStringSelectorComponent,
                 new ViewMetadata({template: `<simple #child></simple>`, directives: [Simple]}))
@@ -52,7 +52,7 @@ export function main() {
   });
   describe('ViewChildren', () => {
     it('should support type selector',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(ViewChildrenTypeSelectorComponent,
                           new ViewMetadata({template: `<simple></simple><simple></simple>`, directives: [Simple]}))
              .createAsync(ViewChildrenTypeSelectorComponent)
@@ -64,7 +64,7 @@ export function main() {
              });
        }));
     it('should support string selector',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(
                 ViewChildrenStringSelectorComponent,
                 new ViewMetadata({template: `<simple #child1></simple><simple #child2></simple>`, directives: [Simple]}))
diff --git a/modules/@angular/core/test/reflection/reflector_common.ts b/modules/@angular/core/test/reflection/reflector_common.ts
index 96868a902b..bf4133894c 100644
--- a/modules/@angular/core/test/reflection/reflector_common.ts
+++ b/modules/@angular/core/test/reflection/reflector_common.ts
@@ -5,26 +5,26 @@ import {
 } from '@angular/core/src/util/decorators';
 
 export class ClassDecoratorMeta {
-  constructor(public value) {}
+  constructor(public value: any /** TODO #9100 */) {}
 }
 
 export class ParamDecoratorMeta {
-  constructor(public value) {}
+  constructor(public value: any /** TODO #9100 */) {}
 }
 
 export class PropDecoratorMeta {
-  constructor(public value) {}
+  constructor(public value: any /** TODO #9100 */) {}
 }
 
-export function classDecorator(value) {
+export function classDecorator(value: any /** TODO #9100 */) {
   return new ClassDecoratorMeta(value);
 }
 
-export function paramDecorator(value) {
+export function paramDecorator(value: any /** TODO #9100 */) {
   return new ParamDecoratorMeta(value);
 }
 
-export function propDecorator(value) {
+export function propDecorator(value: any /** TODO #9100 */) {
   return new PropDecoratorMeta(value);
 }
 
diff --git a/modules/@angular/core/test/reflection/reflector_spec.ts b/modules/@angular/core/test/reflection/reflector_spec.ts
index 0516b67601..3f808fb55d 100644
--- a/modules/@angular/core/test/reflection/reflector_spec.ts
+++ b/modules/@angular/core/test/reflection/reflector_spec.ts
@@ -24,18 +24,18 @@ import {
 } from '@angular/platform-browser/testing'
 
     class AType {
-  value;
+  value: any /** TODO #9100 */;
 
-  constructor(value) { this.value = value; }
+  constructor(value: any /** TODO #9100 */) { this.value = value; }
 }
 
 @ClassDecorator('class')
 class ClassWithDecorators {
-  @PropDecorator("p1") @PropDecorator("p2") a;
-  b;
+  @PropDecorator("p1") @PropDecorator("p2") a: any /** TODO #9100 */;
+  b: any /** TODO #9100 */;
 
   @PropDecorator("p3")
-  set c(value) {
+  set c(value: any /** TODO #9100 */) {
   }
 
   constructor(@ParamDecorator("a") a: AType, @ParamDecorator("b") b: AType) {
@@ -45,19 +45,19 @@ class ClassWithDecorators {
 }
 
 class ClassWithoutDecorators {
-  constructor(a, b) {}
+  constructor(a: any /** TODO #9100 */, b: any /** TODO #9100 */) {}
 }
 
 class TestObj {
-  a;
-  b;
+  a: any /** TODO #9100 */;
+  b: any /** TODO #9100 */;
 
-  constructor(a, b) {
+  constructor(a: any /** TODO #9100 */, b: any /** TODO #9100 */) {
     this.a = a;
     this.b = b;
   }
 
-  identity(arg) { return arg; }
+  identity(arg: any /** TODO #9100 */) { return arg; }
 }
 
 class Interface {}
@@ -83,7 +83,7 @@ class SubClassDoesNotDeclareOnInit extends SuperClassImplementingOnInit {}
 
 export function main() {
   describe('Reflector', () => {
-    var reflector;
+    var reflector: any /** TODO #9100 */;
 
     beforeEach(() => { reflector = new Reflector(new ReflectionCapabilities()); });
 
@@ -122,8 +122,8 @@ export function main() {
       // TODO: remove when issue is solved: https://github.com/angular/angular/issues/4756
       if (!browserDetection.isEdge) {
         it("should check args from no to max", () => {
-          var f = t => reflector.factory(t);
-          var checkArgs = (obj, args) => expect(obj.args).toEqual(args);
+          var f = (t: any /** TODO #9100 */) => reflector.factory(t);
+          var checkArgs = (obj: any /** TODO #9100 */, args: any /** TODO #9100 */) => expect(obj.args).toEqual(args);
 
           // clang-format off
           checkArgs(f(TestObjWith00Args)(), []);
@@ -248,7 +248,7 @@ export function main() {
       });
 
       it("should return a registered getter if available", () => {
-        reflector.registerGetters({"abc": (obj) => "fake"});
+        reflector.registerGetters({"abc": (obj: any /** TODO #9100 */) => "fake"});
         expect(reflector.getter("abc")("anything")).toEqual("fake");
       });
     });
@@ -262,8 +262,8 @@ export function main() {
       });
 
       it("should return a registered setter if available", () => {
-        var updateMe;
-        reflector.registerSetters({"abc": (obj, value) => { updateMe = value; }});
+        var updateMe: any /** TODO #9100 */;
+        reflector.registerSetters({"abc": (obj: any /** TODO #9100 */, value: any /** TODO #9100 */) => { updateMe = value; }});
         reflector.setter("abc")("anything", "fake");
 
         expect(updateMe).toEqual("fake");
@@ -278,7 +278,7 @@ export function main() {
       });
 
       it("should return a registered method if available", () => {
-        reflector.registerMethods({"abc": (obj, args) => args});
+        reflector.registerMethods({"abc": (obj: any /** TODO #9100 */, args: any /** TODO #9100 */) => args});
         expect(reflector.method("abc")("anything", ["fake"])).toEqual(['fake']);
       });
     });
diff --git a/modules/@angular/core/test/testability/testability_spec.ts b/modules/@angular/core/test/testability/testability_spec.ts
index 1ca2006a2f..5bf0cc6139 100644
--- a/modules/@angular/core/test/testability/testability_spec.ts
+++ b/modules/@angular/core/test/testability/testability_spec.ts
@@ -63,7 +63,7 @@ export function main() {
          () => { expect(testability.getPendingRequestCount()).toEqual(0); });
 
       it('should fire whenstable callbacks if pending count is 0',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            testability.whenStable(execute);
            microTask(() => {
              expect(execute).toHaveBeenCalled();
@@ -77,7 +77,7 @@ export function main() {
       });
 
       it('should not call whenstable callbacks when there are pending counts',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            testability.increasePendingRequestCount();
            testability.increasePendingRequestCount();
            testability.whenStable(execute);
@@ -94,7 +94,7 @@ export function main() {
          }));
 
       it('should fire whenstable callbacks when pending drops to 0',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            testability.increasePendingRequestCount();
            testability.whenStable(execute);
 
@@ -118,7 +118,7 @@ export function main() {
       });
 
       it('should fire whenstable callbacks with didWork if pending count is 0',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            testability.whenStable(execute);
            microTask(() => {
              expect(execute).toHaveBeenCalledWith(false);
@@ -127,7 +127,7 @@ export function main() {
          }));
 
       it('should fire whenstable callbacks with didWork when pending drops to 0',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            testability.increasePendingRequestCount();
            testability.whenStable(execute);
 
@@ -149,7 +149,7 @@ export function main() {
 
     describe('NgZone callback logic', () => {
       it('should fire whenstable callback if event is already finished',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            ngZone.stable();
            testability.whenStable(execute);
@@ -169,7 +169,7 @@ export function main() {
       });
 
       it('should fire whenstable callback when event finishes',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            testability.whenStable(execute);
 
@@ -193,7 +193,7 @@ export function main() {
       });
 
       it('should not fire whenstable callback when event did not finish',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            testability.increasePendingRequestCount();
            testability.whenStable(execute);
@@ -215,7 +215,7 @@ export function main() {
          }));
 
       it('should not fire whenstable callback when there are pending counts',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            testability.increasePendingRequestCount();
            testability.increasePendingRequestCount();
@@ -243,7 +243,7 @@ export function main() {
          }));
 
       it('should fire whenstable callback with didWork if event is already finished',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            ngZone.stable();
            testability.whenStable(execute);
@@ -260,7 +260,7 @@ export function main() {
          }));
 
       it('should fire whenstable callback with didwork when event finishes',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            ngZone.unstable();
            testability.whenStable(execute);
 
diff --git a/modules/@angular/core/test/testing_internal_spec.ts b/modules/@angular/core/test/testing_internal_spec.ts
index 3819925d81..5a82f07849 100644
--- a/modules/@angular/core/test/testing_internal_spec.ts
+++ b/modules/@angular/core/test/testing_internal_spec.ts
@@ -5,10 +5,10 @@ import {MapWrapper} from '../../platform-browser/src/facade/collection';
 import {RegExpWrapper} from '../../router/src/facade/lang';
 
 class TestObj {
-  prop;
-  constructor(prop) { this.prop = prop; }
+  prop: any /** TODO #9100 */;
+  constructor(prop: any /** TODO #9100 */) { this.prop = prop; }
   someFunc(): number { return -1; }
-  someComplexFunc(a) { return a; }
+  someComplexFunc(a: any /** TODO #9100 */) { return a; }
 }
 
 class SpyTestObj extends SpyObject {
@@ -65,7 +65,7 @@ export function main() {
     });
 
     describe("spy objects", () => {
-      var spyObj;
+      var spyObj: any /** TODO #9100 */;
 
       beforeEach(() => { spyObj = <any>new SpyTestObj(); });
 
@@ -73,7 +73,7 @@ export function main() {
          () => { expect(spyObj.spy("someFunc")).not.toHaveBeenCalled(); });
 
       it("should record function calls", () => {
-        spyObj.spy("someFunc").andCallFake((a, b) => {return a + b});
+        spyObj.spy("someFunc").andCallFake((a: any /** TODO #9100 */, b: any /** TODO #9100 */) => {return a + b});
 
         expect(spyObj.someFunc(1, 2)).toEqual(3);
         expect(spyObj.spy("someFunc")).toHaveBeenCalledWith(1, 2);
diff --git a/modules/@angular/core/test/util/decorators_spec.ts b/modules/@angular/core/test/util/decorators_spec.ts
index bda6229f29..29531e31a1 100644
--- a/modules/@angular/core/test/util/decorators_spec.ts
+++ b/modules/@angular/core/test/util/decorators_spec.ts
@@ -65,7 +65,7 @@ export function main() {
 
     describe('Class', () => {
       it('should create a class', () => {
-        var i0, i1;
+        var i0: any /** TODO #9100 */, i1: any /** TODO #9100 */;
         var MyClass =
             (<any>TestDecorator('test-works'))
                 .Class(<any>{
@@ -73,9 +73,9 @@ export function main() {
                     constructor: function() {},
                     extendWorks: function() { return 'extend ' + this.arg; }
                   }),
-                  constructor: [String, function(arg) { this.arg = arg; }],
+                  constructor: [String, function(arg: any /** TODO #9100 */) { this.arg = arg; }],
                   methodA:
-                      [i0 = new Inject(String), [i1 = Inject(String), Number], function(a, b) {}],
+                      [i0 = new Inject(String), [i1 = Inject(String), Number], function(a: any /** TODO #9100 */, b: any /** TODO #9100 */) {}],
                   works: function() { return this.arg; },
                   prototype: 'IGNORE'
                 });
diff --git a/modules/@angular/core/test/zone/ng_zone_spec.ts b/modules/@angular/core/test/zone/ng_zone_spec.ts
index 12199a4908..4061b9cb36 100644
--- a/modules/@angular/core/test/zone/ng_zone_spec.ts
+++ b/modules/@angular/core/test/zone/ng_zone_spec.ts
@@ -69,7 +69,7 @@ function runNgZoneNoLog(fn: () => any) {
 export function main() {
   describe("NgZone", () => {
 
-    function createZone(enableLongStackTrace) {
+    function createZone(enableLongStackTrace: any /** TODO #9100 */) {
       return new NgZone({enableLongStackTrace: enableLongStackTrace});
     }
 
@@ -90,7 +90,7 @@ export function main() {
 
       commonTests();
 
-      it('should produce long stack traces', inject([AsyncTestCompleter], (async) => {
+      it('should produce long stack traces', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            macroTask(() => {
              var c: PromiseCompleter<any> = PromiseWrapper.completer();
 
@@ -112,7 +112,7 @@ export function main() {
          }), testTimeout);
 
       it('should produce long stack traces (when using microtasks)',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            macroTask(() => {
              var c: PromiseCompleter<any> = PromiseWrapper.completer();
 
@@ -145,7 +145,7 @@ export function main() {
 
       commonTests();
 
-      it('should disable long stack traces', inject([AsyncTestCompleter], (async) => {
+      it('should disable long stack traces', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            macroTask(() => {
              var c: PromiseCompleter<any> = PromiseWrapper.completer();
 
@@ -213,13 +213,13 @@ function commonTests() {
   });
 
   describe('run', () => {
-    it('should return the body return value from run', inject([AsyncTestCompleter], (async) => {
+    it('should return the body return value from run', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          macroTask(() => { expect(_zone.run(() => { return 6; })).toEqual(6); });
 
          macroTask(() => { async.done(); });
        }), testTimeout);
 
-    it('should call onUnstable and onMicrotaskEmpty', inject([AsyncTestCompleter], (async) => {
+    it('should call onUnstable and onMicrotaskEmpty', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run')));
          macroTask(() => {
            expect(_log.result()).toEqual('onUnstable; run; onMicrotaskEmpty; onStable');
@@ -227,7 +227,7 @@ function commonTests() {
          });
        }), testTimeout);
 
-    it('should call onStable once at the end of event', inject([AsyncTestCompleter], (async) => {
+    it('should call onStable once at the end of event', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          // The test is set up in a way that causes the zone loop to run onMicrotaskEmpty twice
          // then verified that onStable is only called once at the end
 
@@ -251,7 +251,7 @@ function commonTests() {
          }, resultTimer);
        }), testTimeout);
 
-    it('should call standalone onStable', inject([AsyncTestCompleter], (async) => {
+    it('should call standalone onStable', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run')));
 
          macroTask(() => {
@@ -261,7 +261,7 @@ function commonTests() {
        }), testTimeout);
 
     xit('should run subscriber listeners in the subscription zone (outside)',
-        inject([AsyncTestCompleter], (async) => {
+        inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
           // Each subscriber fires a microtask outside the Angular zone. The test
           // then verifies that those microtasks do not cause additional digests.
 
@@ -298,7 +298,7 @@ function commonTests() {
         }), testTimeout);
 
     it('should run subscriber listeners in the subscription zone (inside)',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run')));
 
          // the only practical use-case to run a callback inside the zone is
@@ -320,7 +320,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should run async tasks scheduled inside onStable outside Angular zone',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run')));
 
          ObservableWrapper.subscribe(_zone.onStable, (_) => {
@@ -336,7 +336,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable once before a turn and onMicrotaskEmpty once after the turn',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => {
            macroTask(() => {
              _log.add('run start');
@@ -354,7 +354,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should not run onUnstable and onMicrotaskEmpty for nested Zone.run',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => {
            macroTask(() => {
              _log.add('start run');
@@ -375,7 +375,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should not run onUnstable and onMicrotaskEmpty for nested Zone.run invoked from onMicrotaskEmpty',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('start run')));
 
          ObservableWrapper.subscribe(_zone.onMicrotaskEmpty, (_) => {
@@ -393,7 +393,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty before and after each top-level run',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run1')));
          runNgZoneNoLog(() => macroTask(_log.fn('run2')));
 
@@ -406,7 +406,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty before and after each turn',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var a: PromiseCompleter<string>;
          var b: PromiseCompleter<string>;
 
@@ -437,7 +437,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should run a function outside of the angular zone',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          macroTask(() => { _zone.runOutsideAngular(_log.fn('run')); });
 
          macroTask(() => {
@@ -447,7 +447,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty when an inner microtask is scheduled from outside angular',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var completer: PromiseCompleter<any>;
 
          macroTask(() => {
@@ -484,7 +484,7 @@ function commonTests() {
 
     it('should call onUnstable only before executing a microtask scheduled in onMicrotaskEmpty ' +
            'and not onMicrotaskEmpty after executing the task',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => macroTask(_log.fn('run')));
 
          var ran = false;
@@ -516,7 +516,7 @@ function commonTests() {
 
     it('should call onUnstable and onMicrotaskEmpty for a scheduleMicroTask in onMicrotaskEmpty triggered by ' +
            'a scheduleMicroTask in run',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => {
            macroTask(() => {
              _log.add('scheduleMicroTask');
@@ -551,7 +551,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should execute promises scheduled in onUnstable before promises scheduled in run',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => {
            macroTask(() => {
              _log.add('run start');
@@ -607,7 +607,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty before and after each turn, respectively',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var completerA: PromiseCompleter<any>;
          var completerB: PromiseCompleter<any>;
 
@@ -639,7 +639,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty before and after (respectively) all turns in a chain',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          runNgZoneNoLog(() => {
            macroTask(() => {
              _log.add('run start');
@@ -660,7 +660,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should call onUnstable and onMicrotaskEmpty for promises created outside of run body',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var promise: Promise<any>;
 
          runNgZoneNoLog(() => {
@@ -685,7 +685,7 @@ function commonTests() {
 
   describe('exceptions', () => {
     it('should call the on error callback when it is invoked via zone.runGuarded',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          macroTask(() => {
            var exception = new BaseException('sync');
 
@@ -698,7 +698,7 @@ function commonTests() {
        }), testTimeout);
 
     it('should not call the on error callback but rethrow when it is invoked via zone.run',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          macroTask(() => {
            var exception = new BaseException('sync');
            expect(() => _zone.run(() => { throw exception; })).toThrowError('sync');
@@ -708,7 +708,7 @@ function commonTests() {
          });
        }), testTimeout);
 
-    it('should call onError for errors from microtasks', inject([AsyncTestCompleter], (async) => {
+    it('should call onError for errors from microtasks', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var exception = new BaseException('async');
 
          macroTask(() => { _zone.run(() => { scheduleMicroTask(() => { throw exception; }); }); });
diff --git a/modules/@angular/core/testing/animation/mock_animation_driver.ts b/modules/@angular/core/testing/animation/mock_animation_driver.ts
index 3e54517aa3..b24370ca74 100644
--- a/modules/@angular/core/testing/animation/mock_animation_driver.ts
+++ b/modules/@angular/core/testing/animation/mock_animation_driver.ts
@@ -6,7 +6,7 @@ import {AnimationStyles} from '../../src/animation/animation_styles';
 import {MockAnimationPlayer} from '../../testing/animation/mock_animation_player';
 
 export class MockAnimationDriver extends AnimationDriver {
-  log = [];
+  log: any[] /** TODO #9100 */ = [];
   animate(element: any, startingStyles: AnimationStyles, keyframes: AnimationKeyframe[], duration: number, delay: number,
           easing: string): AnimationPlayer {
     var player = new MockAnimationPlayer();
@@ -30,6 +30,6 @@ function _serializeKeyframes(keyframes: AnimationKeyframe[]): any[] {
 
 function _serializeStyles(styles: AnimationStyles): {[key: string]: any} {
   var flatStyles = {};
-  styles.styles.forEach(entry => StringMapWrapper.forEach(entry, (val, prop) => { flatStyles[prop] = val; }));
+  styles.styles.forEach(entry => StringMapWrapper.forEach(entry, (val: any /** TODO #9100 */, prop: any /** TODO #9100 */) => { (flatStyles as any /** TODO #9100 */)[prop] = val; }));
   return flatStyles;
 }
diff --git a/modules/@angular/core/testing/animation/mock_animation_player.ts b/modules/@angular/core/testing/animation/mock_animation_player.ts
index b8128dd091..71ee5e85d9 100644
--- a/modules/@angular/core/testing/animation/mock_animation_player.ts
+++ b/modules/@angular/core/testing/animation/mock_animation_player.ts
@@ -2,12 +2,12 @@ import {isPresent} from '../../src/facade/lang';
 import {AnimationPlayer} from '../../src/animation/animation_player';
 
 export class MockAnimationPlayer implements AnimationPlayer {
-  private _subscriptions = [];
+  private _subscriptions: any[] /** TODO #9100 */ = [];
   private _finished = false;
   private _destroyed = false;
   public parentPlayer: AnimationPlayer = null;
 
-  public log = [];
+  public log: any[] /** TODO #9100 */ = [];
 
   private _onfinish(): void {
     if (!this._finished) {
@@ -42,6 +42,6 @@ export class MockAnimationPlayer implements AnimationPlayer {
     }
   }
 
-  setPosition(p): void {}
+  setPosition(p: any /** TODO #9100 */): void {}
   getPosition(): number { return 0; }
 }
diff --git a/modules/@angular/core/testing/async.ts b/modules/@angular/core/testing/async.ts
index d95681145f..75d86454e9 100644
--- a/modules/@angular/core/testing/async.ts
+++ b/modules/@angular/core/testing/async.ts
@@ -15,7 +15,7 @@
  */
 export function async(fn: Function): Function {
   return () => new Promise<void>((finishCallback, failCallback) => {
-      var AsyncTestZoneSpec = Zone['AsyncTestZoneSpec'];
+      var AsyncTestZoneSpec = (Zone as any /** TODO #9100 */)['AsyncTestZoneSpec'];
       var testZoneSpec = new AsyncTestZoneSpec(finishCallback, failCallback, 'test');
       var testZone = Zone.current.fork(testZoneSpec);
       return testZone.run(fn);
diff --git a/modules/@angular/core/testing/fake_async.ts b/modules/@angular/core/testing/fake_async.ts
index 5810258b88..a11b18f907 100644
--- a/modules/@angular/core/testing/fake_async.ts
+++ b/modules/@angular/core/testing/fake_async.ts
@@ -1,7 +1,7 @@
 import {BaseException} from '../index';
 import {getTestInjector} from './test_injector';
 
-let _FakeAsyncTestZoneSpecType = Zone['FakeAsyncTestZoneSpec'];
+let _FakeAsyncTestZoneSpecType = (Zone as any /** TODO #9100 */)['FakeAsyncTestZoneSpec'];
 
 /**
  * Wraps a function to be executed in the fakeAsync zone:
@@ -27,7 +27,7 @@ export function fakeAsync(fn: Function): Function {
   let fakeAsyncTestZoneSpec = new _FakeAsyncTestZoneSpecType();
   let fakeAsyncZone = Zone.current.fork(fakeAsyncTestZoneSpec);
 
-  return function(...args) {
+  return function(...args: any[] /** TODO #9100 */) {
     let res = fakeAsyncZone.run(() => {
       let res = fn(...args);
       flushMicrotasks();
diff --git a/modules/@angular/core/testing/lang_utils.ts b/modules/@angular/core/testing/lang_utils.ts
index a6fdea6267..8561a87556 100644
--- a/modules/@angular/core/testing/lang_utils.ts
+++ b/modules/@angular/core/testing/lang_utils.ts
@@ -1,4 +1,4 @@
-export function getTypeOf(instance) {
+export function getTypeOf(instance: any /** TODO #9100 */) {
   return instance.constructor;
 }
 
diff --git a/modules/@angular/core/testing/logger.ts b/modules/@angular/core/testing/logger.ts
index 77e23a2c12..cd8eadf300 100644
--- a/modules/@angular/core/testing/logger.ts
+++ b/modules/@angular/core/testing/logger.ts
@@ -6,9 +6,9 @@ export class Log {
 
   constructor() { this.logItems = []; }
 
-  add(value): void { this.logItems.push(value); }
+  add(value: any /** TODO #9100 */): void { this.logItems.push(value); }
 
-  fn(value) {
+  fn(value: any /** TODO #9100 */) {
     return (a1: any = null, a2: any = null, a3: any = null, a4: any = null, a5: any = null) => {
       this.logItems.push(value);
     };
diff --git a/modules/@angular/core/testing/regexp.ts b/modules/@angular/core/testing/regexp.ts
index d1965fd49f..cd284a68e8 100644
--- a/modules/@angular/core/testing/regexp.ts
+++ b/modules/@angular/core/testing/regexp.ts
@@ -5,5 +5,5 @@ var _RE_SPECIAL_CHARS =
 var _ESCAPE_RE = RegExpWrapper.create(`[\\${_RE_SPECIAL_CHARS.join('\\')}]`);
 export function containsRegexp(input: string): RegExp {
   return RegExpWrapper.create(
-      StringWrapper.replaceAllMapped(input, _ESCAPE_RE, (match) => `\\${match[0]}`));
+      StringWrapper.replaceAllMapped(input, _ESCAPE_RE, (match: any /** TODO #9100 */) => `\\${match[0]}`));
 }
diff --git a/modules/@angular/core/testing/testing.ts b/modules/@angular/core/testing/testing.ts
index 85758b1d97..2ec9e2c042 100644
--- a/modules/@angular/core/testing/testing.ts
+++ b/modules/@angular/core/testing/testing.ts
@@ -8,7 +8,7 @@ import {isPromise} from '../src/facade/lang';
 
 export {inject, async, injectAsync} from './test_injector';
 
-declare var global;
+declare var global: any /** TODO #9100 */;
 
 var _global = <any>(typeof window === 'undefined' ? global : window);
 
diff --git a/modules/@angular/core/testing/testing_internal.ts b/modules/@angular/core/testing/testing_internal.ts
index 9b6957b2e5..0ae95de558 100644
--- a/modules/@angular/core/testing/testing_internal.ts
+++ b/modules/@angular/core/testing/testing_internal.ts
@@ -11,7 +11,7 @@ export {AsyncTestCompleter} from './async_test_completer';
 export {MockAnimationPlayer} from './animation/mock_animation_player';
 export {MockAnimationDriver} from './animation/mock_animation_driver';
 
-export var proxy: ClassDecorator = (t) => t;
+export var proxy: ClassDecorator = (t: any /** TODO #9100 */) => t;
 
 var _global = <any>(typeof window === 'undefined' ? global : window);
 
@@ -25,7 +25,7 @@ var jsmIt = _global.it;
 var jsmIIt = _global.fit;
 var jsmXIt = _global.xit;
 
-var runnerStack = [];
+var runnerStack: any[] /** TODO #9100 */ = [];
 var inIt = false;
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 3000;
 var globalTimeOut = jasmine.DEFAULT_TIMEOUT_INTERVAL;
@@ -53,7 +53,7 @@ class BeforeEachRunner {
 // Reset the test providers before each test
 jsmBeforeEach(() => { testInjector.reset(); });
 
-function _describe(jsmFn, ...args) {
+function _describe(jsmFn: any /** TODO #9100 */, ...args: any[] /** TODO #9100 */) {
   var parentRunner = runnerStack.length === 0 ? null : runnerStack[runnerStack.length - 1];
   var runner = new BeforeEachRunner(parentRunner);
   runnerStack.push(runner);
@@ -62,15 +62,15 @@ function _describe(jsmFn, ...args) {
   return suite;
 }
 
-export function describe(...args): void {
+export function describe(...args: any[] /** TODO #9100 */): void {
   return _describe(jsmDescribe, ...args);
 }
 
-export function ddescribe(...args): void {
+export function ddescribe(...args: any[] /** TODO #9100 */): void {
   return _describe(jsmDDescribe, ...args);
 }
 
-export function xdescribe(...args): void {
+export function xdescribe(...args: any[] /** TODO #9100 */): void {
   return _describe(jsmXDescribe, ...args);
 }
 
@@ -96,7 +96,7 @@ export function beforeEach(fn: Function): void {
  *     {provide: SomeToken, useValue: myValue},
  *   ]);
  */
-export function beforeEachProviders(fn): void {
+export function beforeEachProviders(fn: any /** TODO #9100 */): void {
   jsmBeforeEach(() => {
     var providers = fn();
     if (!providers) return;
@@ -107,7 +107,7 @@ export function beforeEachProviders(fn): void {
 /**
  * @deprecated
  */
-export function beforeEachBindings(fn): void {
+export function beforeEachBindings(fn: any /** TODO #9100 */): void {
   beforeEachProviders(fn);
 }
 
@@ -120,7 +120,7 @@ function _it(jsmFn: Function, name: string, testFn: Function, testTimeOut: numbe
   var runner = runnerStack[runnerStack.length - 1];
   var timeOut = Math.max(globalTimeOut, testTimeOut);
 
-  jsmFn(name, (done) => {
+  jsmFn(name, (done: any /** TODO #9100 */) => {
     var completerProvider = {
       provide: AsyncTestCompleter,
       useFactory: () => {
@@ -150,15 +150,15 @@ function _it(jsmFn: Function, name: string, testFn: Function, testTimeOut: numbe
   }, timeOut);
 }
 
-export function it(name, fn, timeOut = null): void {
+export function it(name: any /** TODO #9100 */, fn: any /** TODO #9100 */, timeOut: any /** TODO #9100 */ = null): void {
   return _it(jsmIt, name, fn, timeOut);
 }
 
-export function xit(name, fn, timeOut = null): void {
+export function xit(name: any /** TODO #9100 */, fn: any /** TODO #9100 */, timeOut: any /** TODO #9100 */ = null): void {
   return _it(jsmXIt, name, fn, timeOut);
 }
 
-export function iit(name, fn, timeOut = null): void {
+export function iit(name: any /** TODO #9100 */, fn: any /** TODO #9100 */, timeOut: any /** TODO #9100 */ = null): void {
   return _it(jsmIIt, name, fn, timeOut);
 }
 
@@ -170,14 +170,14 @@ export interface GuinessCompatibleSpy extends jasmine.Spy {
    * function. */
   andCallFake(fn: Function): GuinessCompatibleSpy;
   /** removes all recorded calls */
-  reset();
+  reset(): any /** TODO #9100 */;
 }
 
 export class SpyObject {
-  constructor(type = null) {
+  constructor(type: any /** TODO #9100 */ = null) {
     if (type) {
       for (var prop in type.prototype) {
-        var m = null;
+        var m: any /** TODO #9100 */ = null;
         try {
           m = type.prototype[prop];
         } catch (e) {
@@ -193,18 +193,18 @@ export class SpyObject {
     }
   }
   // Noop so that SpyObject has the same interface as in Dart
-  noSuchMethod(args) {}
+  noSuchMethod(args: any /** TODO #9100 */) {}
 
-  spy(name) {
-    if (!this[name]) {
-      this[name] = this._createGuinnessCompatibleSpy(name);
+  spy(name: any /** TODO #9100 */) {
+    if (!(this as any /** TODO #9100 */)[name]) {
+      (this as any /** TODO #9100 */)[name] = this._createGuinnessCompatibleSpy(name);
     }
-    return this[name];
+    return (this as any /** TODO #9100 */)[name];
   }
 
-  prop(name, value) { this[name] = value; }
+  prop(name: any /** TODO #9100 */, value: any /** TODO #9100 */) { (this as any /** TODO #9100 */)[name] = value; }
 
-  static stub(object = null, config = null, overrides = null) {
+  static stub(object: any /** TODO #9100 */ = null, config: any /** TODO #9100 */ = null, overrides: any /** TODO #9100 */ = null) {
     if (!(object instanceof SpyObject)) {
       overrides = config;
       config = object;
@@ -212,12 +212,12 @@ export class SpyObject {
     }
 
     var m = StringMapWrapper.merge(config, overrides);
-    StringMapWrapper.forEach(m, (value, key) => { object.spy(key).andReturn(value); });
+    StringMapWrapper.forEach(m, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => { object.spy(key).andReturn(value); });
     return object;
   }
 
   /** @internal */
-  _createGuinnessCompatibleSpy(name): GuinessCompatibleSpy {
+  _createGuinnessCompatibleSpy(name: any /** TODO #9100 */): GuinessCompatibleSpy {
     var newSpy: GuinessCompatibleSpy = <any>jasmine.createSpy(name);
     newSpy.andCallFake = <any>newSpy.and.callFake;
     newSpy.andReturn = <any>newSpy.and.returnValue;
diff --git a/modules/@angular/facade/src/async.ts b/modules/@angular/facade/src/async.ts
index 1c2550d2b6..524d9a37d6 100644
--- a/modules/@angular/facade/src/async.ts
+++ b/modules/@angular/facade/src/async.ts
@@ -129,13 +129,13 @@ export class EventEmitter<T> extends Subject<T> {
   next(value: any) { super.next(value); }
 
   subscribe(generatorOrNext?: any, error?: any, complete?: any): any {
-    let schedulerFn;
-    let errorFn = (err: any) => null;
-    let completeFn = () => null;
+    let schedulerFn: any /** TODO #9100 */;
+    let errorFn = (err: any): any /** TODO #9100 */ => null;
+    let completeFn = (): any /** TODO #9100 */ => null;
 
     if (generatorOrNext && typeof generatorOrNext === 'object') {
-      schedulerFn = this.__isAsync ? (value) => { setTimeout(() => generatorOrNext.next(value)); } :
-                                    (value) => { generatorOrNext.next(value); };
+      schedulerFn = this.__isAsync ? (value: any /** TODO #9100 */) => { setTimeout(() => generatorOrNext.next(value)); } :
+                                    (value: any /** TODO #9100 */) => { generatorOrNext.next(value); };
 
       if (generatorOrNext.error) {
         errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :
@@ -147,8 +147,8 @@ export class EventEmitter<T> extends Subject<T> {
                                      () => { generatorOrNext.complete(); };
       }
     } else {
-      schedulerFn = this.__isAsync ? (value) => { setTimeout(() => generatorOrNext(value)); } :
-                                    (value) => { generatorOrNext(value); };
+      schedulerFn = this.__isAsync ? (value: any /** TODO #9100 */) => { setTimeout(() => generatorOrNext(value)); } :
+                                    (value: any /** TODO #9100 */) => { generatorOrNext(value); };
 
       if (error) {
         errorFn =
diff --git a/modules/@angular/facade/src/browser.ts b/modules/@angular/facade/src/browser.ts
index 33e2f35157..ca8277f540 100644
--- a/modules/@angular/facade/src/browser.ts
+++ b/modules/@angular/facade/src/browser.ts
@@ -6,7 +6,7 @@ var win = typeof window !== 'undefined' && window || <any>{};
 export {win as window};
 export var document = win.document;
 export var location = win.location;
-export var gc = win['gc'] ? () => win['gc']() : () => null;
+export var gc = win['gc'] ? () => win['gc']() : (): any /** TODO #9100 */ => null;
 export var performance = win['performance'] ? win['performance'] : null;
 export const Event = win['Event'];
 export const MouseEvent = win['MouseEvent'];
diff --git a/modules/@angular/facade/src/collection.ts b/modules/@angular/facade/src/collection.ts
index e0256f66f6..8585b27b4f 100644
--- a/modules/@angular/facade/src/collection.ts
+++ b/modules/@angular/facade/src/collection.ts
@@ -34,11 +34,11 @@ var createMapFromMap: {(m: Map<any, any>): Map<any, any>} = (function() {
     return map;
   };
 })();
-var _clearValues: {(m: Map<any, any>)} = (function() {
+var _clearValues: {(m: Map<any, any>): void} = (function() {
   if ((<any>(new Map()).keys()).next) {
     return function _clearValues(m: Map<any, any>) {
       var keyIterator = m.keys();
-      var k;
+      var k: any /** TODO #???? */;
       while (!((k = (<any>keyIterator).next()).done)) {
         m.set(k.value, null);
       }
@@ -154,7 +154,7 @@ export class StringMapWrapper {
     if (k1.length != k2.length) {
       return false;
     }
-    var key;
+    var key: any /** TODO #???? */;
     for (var i = 0; i < k1.length; i++) {
       key = k1[i];
       if (m1[key] !== m2[key]) {
@@ -249,7 +249,7 @@ export class ListWrapper {
     if (list.length == 0) {
       return null;
     }
-    var solution = null;
+    var solution: any /** TODO #???? */ = null;
     var maxValue = -Infinity;
     for (var index = 0; index < list.length; index++) {
       var candidate = list[index];
@@ -266,7 +266,7 @@ export class ListWrapper {
   }
 
   static flatten<T>(list: Array<T | T[]>): T[] {
-    var target = [];
+    var target: any[] /** TODO #???? */ = [];
     _flattenArray(list, target);
     return target;
   }
@@ -320,7 +320,7 @@ export function iterateListLike(obj: any, fn: Function) {
     }
   } else {
     var iterator = obj[getSymbolIterator()]();
-    var item;
+    var item: any /** TODO #???? */;
     while (!((item = iterator.next()).done)) {
       fn(item.value);
     }
diff --git a/modules/@angular/facade/src/exceptions.ts b/modules/@angular/facade/src/exceptions.ts
index e04dc91f3a..da8ee281c9 100644
--- a/modules/@angular/facade/src/exceptions.ts
+++ b/modules/@angular/facade/src/exceptions.ts
@@ -23,8 +23,8 @@ export class BaseException extends Error {
 export class WrappedException extends BaseWrappedException {
   private _wrapperStack: any;
 
-  constructor(private _wrapperMessage: string, private _originalException, private _originalStack?,
-              private _context?) {
+  constructor(private _wrapperMessage: string, private _originalException: any /** TODO #9100 */, private _originalStack?: any /** TODO #9100 */,
+              private _context?: any /** TODO #9100 */) {
     super(_wrapperMessage);
     this._wrapperStack = (<any>new Error(_wrapperMessage)).stack;
   }
diff --git a/modules/@angular/facade/src/intl.ts b/modules/@angular/facade/src/intl.ts
index 2e75bb8bf6..2024f110fd 100644
--- a/modules/@angular/facade/src/intl.ts
+++ b/modules/@angular/facade/src/intl.ts
@@ -132,12 +132,12 @@ function hour12Modify(options: Intl.DateTimeFormatOptions,
 
 function digitCondition(prop: string, len: number): Intl.DateTimeFormatOptions {
   var result = {};
-  result[prop] = len == 2 ? '2-digit' : 'numeric';
+  (result as any /** TODO #9100 */)[prop] = len == 2 ? '2-digit' : 'numeric';
   return result;
 }
 function nameCondition(prop: string, len: number): Intl.DateTimeFormatOptions {
   var result = {};
-  result[prop] = len < 4 ? 'short' : 'long';
+  (result as any /** TODO #9100 */)[prop] = len < 4 ? 'short' : 'long';
   return result;
 }
 
@@ -161,11 +161,11 @@ var datePartsFormatterCache: Map<string, string[]> = new Map<string, string[]>()
 
 function dateFormatter(format: string, date: Date, locale: string): string {
   var text = '';
-  var match;
-  var fn;
+  var match: any /** TODO #9100 */;
+  var fn: any /** TODO #9100 */;
   var parts: string[] = [];
-  if (PATTERN_ALIASES[format]) {
-    return PATTERN_ALIASES[format](date, locale);
+  if ((PATTERN_ALIASES as any /** TODO #9100 */)[format]) {
+    return (PATTERN_ALIASES as any /** TODO #9100 */)[format](date, locale);
   }
 
 
@@ -189,7 +189,7 @@ function dateFormatter(format: string, date: Date, locale: string): string {
   }
 
   parts.forEach(part => {
-    fn = DATE_FORMATS[part];
+    fn = (DATE_FORMATS as any /** TODO #9100 */)[part];
     text += fn ? fn(date, locale) :
                  part === "''" ? "'" : part.replace(/(^'|'$)/g, '').replace(/''/g, "'");
   });
@@ -198,7 +198,7 @@ function dateFormatter(format: string, date: Date, locale: string): string {
 }
 
 var slice = [].slice;
-function concat(array1, array2, index): string[] {
+function concat(array1: any /** TODO #9100 */, array2: any /** TODO #9100 */, index: any /** TODO #9100 */): string[] {
   return array1.concat(slice.call(array2, index));
 }
 
diff --git a/modules/@angular/facade/src/lang.ts b/modules/@angular/facade/src/lang.ts
index 35c50515a9..d681099e67 100644
--- a/modules/@angular/facade/src/lang.ts
+++ b/modules/@angular/facade/src/lang.ts
@@ -21,11 +21,11 @@ export interface BrowserNodeGlobal {
 }
 
 // TODO(jteplitz602): Load WorkerGlobalScope from lib.webworker.d.ts file #3492
-declare var WorkerGlobalScope;
+declare var WorkerGlobalScope: any /** TODO #9100 */;
 // CommonJS / Node have global context exposed as "global" variable.
 // We don't want to include the whole node.d.ts this this compilation unit so we'll just fake
 // the global "global" var for now.
-declare var global;
+declare var global: any /** TODO #9100 */;
 
 var globalScope: BrowserNodeGlobal;
 if (typeof window === 'undefined') {
@@ -64,7 +64,7 @@ export interface Type extends Function {}
 /**
  * Runtime representation of a type that is constructable (non-abstract).
  */
-export interface ConcreteType extends Type { new (...args): any; }
+export interface ConcreteType extends Type { new (...args: any[] /** TODO #9100 */): any; }
 
 export function getTypeNameForDebugging(type: Type): string {
   if (type['name']) {
@@ -157,13 +157,13 @@ export function isArray(obj: any): boolean {
   return Array.isArray(obj);
 }
 
-export function isDate(obj): boolean {
+export function isDate(obj: any /** TODO #9100 */): boolean {
   return obj instanceof Date && !isNaN(obj.valueOf());
 }
 
 export function noop() {}
 
-export function stringify(token): string {
+export function stringify(token: any /** TODO #9100 */): string {
   if (typeof token === 'string') {
     return token;
   }
@@ -187,15 +187,15 @@ export function stringify(token): string {
 // serialize / deserialize enum exist only for consistency with dart API
 // enums in typescript don't need to be serialized
 
-export function serializeEnum(val): number {
+export function serializeEnum(val: any /** TODO #9100 */): number {
   return val;
 }
 
-export function deserializeEnum(val, values: Map<number, any>): any {
+export function deserializeEnum(val: any /** TODO #9100 */, values: Map<number, any>): any {
   return val;
 }
 
-export function resolveEnumToken(enumValue, val): string {
+export function resolveEnumToken(enumValue: any /** TODO #9100 */, val: any /** TODO #9100 */): string {
   return enumValue[val];
 }
 
@@ -245,7 +245,7 @@ export class StringWrapper {
   }
 
   static replaceAllMapped(s: string, from: RegExp, cb: Function): string {
-    return s.replace(from, function(...matches) {
+    return s.replace(from, function(...matches: any[] /** TODO #9100 */) {
       // Remove offset & string from the result array
       matches.splice(-2, 2);
       // The callback receives match, p1, ..., pn
@@ -267,7 +267,7 @@ export class StringWrapper {
 }
 
 export class StringJoiner {
-  constructor(public parts = []) {}
+  constructor(public parts: any[] /** TODO #9100 */ = []) {}
 
   add(part: string): void { this.parts.push(part); }
 
@@ -385,7 +385,7 @@ export class FunctionWrapper {
 }
 
 // JS has NaN !== NaN
-export function looseIdentical(a, b): boolean {
+export function looseIdentical(a: any /** TODO #9100 */, b: any /** TODO #9100 */): boolean {
   return a === b || typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b);
 }
 
@@ -454,8 +454,8 @@ export function setValueOnPath(global: any, path: string, value: any) {
 }
 
 // When Symbol.iterator doesn't exist, retrieves the key used in es6-shim
-declare var Symbol;
-var _symbolIterator = null;
+declare var Symbol: any /** TODO #9100 */;
+var _symbolIterator: any /** TODO #9100 */ = null;
 export function getSymbolIterator(): string | symbol {
   if (isBlank(_symbolIterator)) {
     if (isPresent((<any>globalScope).Symbol) && isPresent(Symbol.iterator)) {
@@ -466,7 +466,7 @@ export function getSymbolIterator(): string | symbol {
       for (var i = 0; i < keys.length; ++i) {
         var key = keys[i];
         if (key !== 'entries' && key !== 'size' &&
-            Map.prototype[key] === Map.prototype['entries']) {
+            (Map as any /** TODO #9100 */).prototype[key] === Map.prototype['entries']) {
           _symbolIterator = key;
         }
       }
@@ -478,8 +478,8 @@ export function getSymbolIterator(): string | symbol {
 export function evalExpression(sourceUrl: string, expr: string, declarations: string,
                                vars: {[key: string]: any}): any {
   var fnBody = `${declarations}\nreturn ${expr}\n//# sourceURL=${sourceUrl}`;
-  var fnArgNames = [];
-  var fnArgValues = [];
+  var fnArgNames: any[] /** TODO #9100 */ = [];
+  var fnArgValues: any[] /** TODO #9100 */ = [];
   for (var argName in vars) {
     fnArgNames.push(argName);
     fnArgValues.push(vars[argName]);
diff --git a/modules/@angular/facade/src/math.ts b/modules/@angular/facade/src/math.ts
index e9deca9eab..7b191cf5c4 100644
--- a/modules/@angular/facade/src/math.ts
+++ b/modules/@angular/facade/src/math.ts
@@ -1,4 +1,4 @@
 import {global} from './lang';
 
 export var Math = global.Math;
-export var NaN = typeof NaN;
+export var NaN: any /** TODO #???? */ = typeof NaN;
diff --git a/modules/@angular/facade/src/promise.ts b/modules/@angular/facade/src/promise.ts
index b4fd77dfa5..a7e073f2b5 100644
--- a/modules/@angular/facade/src/promise.ts
+++ b/modules/@angular/facade/src/promise.ts
@@ -15,7 +15,7 @@ export class PromiseCompleter<R> {
 export class PromiseWrapper {
   static resolve<T>(obj: T): Promise<T> { return Promise.resolve(obj); }
 
-  static reject(obj: any, _): Promise<any> { return Promise.reject(obj); }
+  static reject(obj: any, _: any /** TODO #9100 */): Promise<any> { return Promise.reject(obj); }
 
   // Note: We can't rename this method into `catch`, as this is not a valid
   // method name in Dart.
diff --git a/modules/@angular/facade/test/async_spec.ts b/modules/@angular/facade/test/async_spec.ts
index 89fbc4f923..4c7a113878 100644
--- a/modules/@angular/facade/test/async_spec.ts
+++ b/modules/@angular/facade/test/async_spec.ts
@@ -18,7 +18,7 @@ export function main() {
 
     beforeEach(() => { emitter = new EventEmitter(); });
 
-    it("should call the next callback", inject([AsyncTestCompleter], (async) => {
+    it("should call the next callback", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          ObservableWrapper.subscribe(emitter, (value) => {
            expect(value).toEqual(99);
            async.done();
@@ -27,7 +27,7 @@ export function main() {
          ObservableWrapper.callEmit(emitter, 99);
        }));
 
-    it("should call the throw callback", inject([AsyncTestCompleter], (async) => {
+    it("should call the throw callback", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          ObservableWrapper.subscribe(emitter, (_) => {}, (error) => {
            expect(error).toEqual("Boom");
            async.done();
@@ -35,12 +35,12 @@ export function main() {
          ObservableWrapper.callError(emitter, "Boom");
        }));
 
-    it("should work when no throw callback is provided", inject([AsyncTestCompleter], (async) => {
+    it("should work when no throw callback is provided", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          ObservableWrapper.subscribe(emitter, (_) => {}, (_) => { async.done(); });
          ObservableWrapper.callError(emitter, "Boom");
        }));
 
-    it("should call the return callback", inject([AsyncTestCompleter], (async) => {
+    it("should call the return callback", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          ObservableWrapper.subscribe(emitter, (_) => {}, (_) => {}, () => { async.done(); });
 
          ObservableWrapper.callComplete(emitter);
@@ -57,8 +57,8 @@ export function main() {
     // 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("delivers next and error events synchronously", inject([AsyncTestCompleter], (async) => {
-           let log = [];
+      it("delivers next and error events synchronously", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
+           let log: any[] /** TODO #9100 */ = [];
            ObservableWrapper.subscribe(emitter,
                                        (x) => {
                                          log.push(x);
@@ -77,7 +77,7 @@ export function main() {
          }));
 
       it("delivers next and complete events synchronously", () => {
-           let log = [];
+           let log: any[] /** TODO #9100 */ = [];
            ObservableWrapper.subscribe(emitter,
                                        (x) => {
                                          log.push(x);
@@ -96,9 +96,9 @@ export function main() {
       });
     }
 
-    it('delivers events asynchronously when forced to async mode', inject([AsyncTestCompleter], (async) => {
+    it('delivers events asynchronously when forced to async mode', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
       var e = new EventEmitter(true);
-      var log = [];
+      var log: any[] /** TODO #9100 */ = [];
       ObservableWrapper.subscribe(e, (x) => {
         log.push(x);
         expect(log).toEqual([1, 3, 2]);
@@ -149,7 +149,7 @@ export function main() {
   // See ECMAScript 6 Spec 25.4.4.1
   describe("PromiseWrapper", () => {
     describe("#all", () => {
-      it("should combine lists of Promises", inject([AsyncTestCompleter], (async) => {
+      it("should combine lists of Promises", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var one = PromiseWrapper.completer();
            var two = PromiseWrapper.completer();
 
@@ -173,7 +173,7 @@ export function main() {
 
       [null, true, false, 10, 'thing', {}, []].forEach(abruptCompletion => {
         it(`should treat "${abruptCompletion}" as an "abrupt completion"`,
-           inject([AsyncTestCompleter], (async) => {
+           inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
              var one = PromiseWrapper.completer();
 
              var all = PromiseWrapper.all([one.promise, abruptCompletion]);
diff --git a/modules/@angular/facade/test/collection_spec.ts b/modules/@angular/facade/test/collection_spec.ts
index 648f6af137..04ae20a8dd 100644
--- a/modules/@angular/facade/test/collection_spec.ts
+++ b/modules/@angular/facade/test/collection_spec.ts
@@ -91,12 +91,12 @@ export function main() {
     });
 
     describe('forEachWithIndex', () => {
-      var l;
+      var l: any /** TODO #9100 */;
 
       beforeEach(() => { l = ["a", "b"]; });
 
       it('should iterate over an array passing values and indices', () => {
-        var record = [];
+        var record: any[] /** TODO #9100 */ = [];
         ListWrapper.forEachWithIndex(l, (value, index) => record.push([value, index]));
         expect(record).toEqual([["a", 0], ["b", 1]]);
       });
diff --git a/modules/@angular/facade/test/lang_spec.ts b/modules/@angular/facade/test/lang_spec.ts
index 8d738de3dd..f862eacc0d 100644
--- a/modules/@angular/facade/test/lang_spec.ts
+++ b/modules/@angular/facade/test/lang_spec.ts
@@ -21,8 +21,8 @@ export function main() {
     it('should expose the index for each match', () => {
       var re = /(!)/g;
       var matcher = RegExpWrapper.matcher(re, '0!23!567!!');
-      var indexes = [];
-      var m;
+      var indexes: any[] /** TODO #9100 */ = [];
+      var m: any /** TODO #9100 */;
 
       while (isPresent(m = RegExpMatcherWrapper.next(matcher))) {
         indexes.push(m.index);
@@ -44,7 +44,7 @@ export function main() {
 
     it("should implement replace all", () => {
       let re = /(\d)+/g;
-      let m = RegExpWrapper.replaceAll(re, 'a1b2c', (match) => `!${match[1]}!`);
+      let m = RegExpWrapper.replaceAll(re, 'a1b2c', (match: any /** TODO #9100 */) => `!${match[1]}!`);
       expect(m).toEqual('a!1!b!2!c');
     });
   });
@@ -57,7 +57,7 @@ export function main() {
   });
 
   describe('String', () => {
-    var s;
+    var s: any /** TODO #9100 */;
 
     describe('slice', () => {
       beforeEach(() => { s = "abcdefghij"; });
diff --git a/modules/@angular/http/src/backends/xhr_backend.ts b/modules/@angular/http/src/backends/xhr_backend.ts
index 305fc0da2d..b261c89188 100644
--- a/modules/@angular/http/src/backends/xhr_backend.ts
+++ b/modules/@angular/http/src/backends/xhr_backend.ts
@@ -107,7 +107,7 @@ export class XHRConnection implements Connection {
     });
   }
 
-  setDetectedContentType(req, _xhr) {
+  setDetectedContentType(req: any /** TODO #9100 */, _xhr: any /** TODO #9100 */) {
     // Skip if a custom Content-Type header is provided
     if (isPresent(req.headers) && isPresent(req.headers['Content-Type'])) {
       return;
diff --git a/modules/@angular/http/src/headers.ts b/modules/@angular/http/src/headers.ts
index b1deb31d5d..7c65ab29b2 100644
--- a/modules/@angular/http/src/headers.ts
+++ b/modules/@angular/http/src/headers.ts
@@ -128,11 +128,11 @@ export class Headers {
   toJSON(): {[key: string]: any} {
     let serializableHeaders = {};
     this._headersMap.forEach((values: string[], name: string) => {
-      let list = [];
+      let list: any[] /** TODO #9100 */ = [];
 
-      iterateListLike(values, val => list = ListWrapper.concat(list, val.split(',')));
+      iterateListLike(values, (val: any /** TODO #9100 */) => list = ListWrapper.concat(list, val.split(',')));
 
-      serializableHeaders[name] = list;
+      (serializableHeaders as any /** TODO #9100 */)[name] = list;
     });
     return serializableHeaders;
   }
diff --git a/modules/@angular/http/src/static_request.ts b/modules/@angular/http/src/static_request.ts
index 4dd768086e..840af97bd6 100644
--- a/modules/@angular/http/src/static_request.ts
+++ b/modules/@angular/http/src/static_request.ts
@@ -168,6 +168,6 @@ export class Request {
 
 const noop = function () {};
 const w = typeof window == 'object' ? window : noop;
-const FormData = w['FormData'] || noop;
-const Blob = w['Blob'] || noop;
-const ArrayBuffer = w['ArrayBuffer'] || noop;
+const FormData = (w as any /** TODO #9100 */)['FormData'] || noop;
+const Blob = (w as any /** TODO #9100 */)['Blob'] || noop;
+const ArrayBuffer = (w as any /** TODO #9100 */)['ArrayBuffer'] || noop;
diff --git a/modules/@angular/http/test/backends/xhr_backend_spec.ts b/modules/@angular/http/test/backends/xhr_backend_spec.ts
index 8449865d25..0667a77fa1 100644
--- a/modules/@angular/http/test/backends/xhr_backend_spec.ts
+++ b/modules/@angular/http/test/backends/xhr_backend_spec.ts
@@ -264,7 +264,7 @@ export function main() {
                                   'application/x-www-form-urlencoded;charset=UTF-8');
       });
 
-      if (global['Blob']) {
+      if ((global as any /** TODO #9100 */)['Blob']) {
         it('should use FormData body and detect content type header to the request', () => {
           var body = new FormData();
           body.append('test1', 'val1');
@@ -385,7 +385,7 @@ export function main() {
            existingXHRs[0].dispatchEvent('load');
          }));
 
-      it('should set ok to true on 200 return', inject([AsyncTestCompleter], async => {
+      it('should set ok to true on 200 return', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
         var statusCode = 200;
         var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
           new ResponseOptions({status: statusCode}));
@@ -399,7 +399,7 @@ export function main() {
         existingXHRs[0].dispatchEvent('load');
       }));
 
-      it('should set ok to false on 300 return', inject([AsyncTestCompleter], async => {
+      it('should set ok to false on 300 return', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
         var statusCode = 300;
         var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
           new ResponseOptions({status: statusCode}));
diff --git a/modules/@angular/http/test/headers_spec.ts b/modules/@angular/http/test/headers_spec.ts
index de987bcb14..83812b1e00 100644
--- a/modules/@angular/http/test/headers_spec.ts
+++ b/modules/@angular/http/test/headers_spec.ts
@@ -65,9 +65,9 @@ export function main() {
 
 
     describe('.toJSON()', () => {
-      let headers = null;
-      let inputArr = null;
-      let obj = null;
+      let headers: any /** TODO #9100 */ = null;
+      let inputArr: any /** TODO #9100 */ = null;
+      let obj: any /** TODO #9100 */ = null;
 
       beforeEach(() => {
         headers = new Headers();
diff --git a/modules/@angular/platform-browser/src/browser/browser_adapter.ts b/modules/@angular/platform-browser/src/browser/browser_adapter.ts
index 97064f98d5..3442393063 100644
--- a/modules/@angular/platform-browser/src/browser/browser_adapter.ts
+++ b/modules/@angular/platform-browser/src/browser/browser_adapter.ts
@@ -60,7 +60,7 @@ var _chromeNumKeyPadMap = {
 export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   parse(templateHtml: string) { throw new Error("parse not implemented"); }
   static makeCurrent() { setRootDomAdapter(new BrowserDomAdapter()); }
-  hasProperty(element, name: string): boolean { return name in element; }
+  hasProperty(element: any /** TODO #9100 */, name: string): boolean { return name in element; }
   setProperty(el: /*element*/ any, name: string, value: any) { el[name] = value; }
   getProperty(el: /*element*/ any, name: string): any { return el[name]; }
   invoke(el: /*element*/ any, methodName: string, args: any[]): any {
@@ -68,7 +68,7 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   }
 
   // TODO(tbosch): move this into a separate environment class once we have it
-  logError(error) {
+  logError(error: any /** TODO #9100 */) {
     if (window.console.error) {
       window.console.error(error);
     } else {
@@ -76,9 +76,9 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
     }
   }
 
-  log(error) { window.console.log(error); }
+  log(error: any /** TODO #9100 */) { window.console.log(error); }
 
-  logGroup(error) {
+  logGroup(error: any /** TODO #9100 */) {
     if (window.console.group) {
       window.console.group(error);
       this.logError(error);
@@ -96,22 +96,22 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   get attrToPropMap(): any { return _attrToPropMap; }
 
   query(selector: string): any { return document.querySelector(selector); }
-  querySelector(el, selector: string): HTMLElement { return el.querySelector(selector); }
-  querySelectorAll(el, selector: string): any[] { return el.querySelectorAll(selector); }
-  on(el, evt, listener) { el.addEventListener(evt, listener, false); }
-  onAndCancel(el, evt, listener): Function {
+  querySelector(el: any /** TODO #9100 */, selector: string): HTMLElement { return el.querySelector(selector); }
+  querySelectorAll(el: any /** TODO #9100 */, selector: string): any[] { return el.querySelectorAll(selector); }
+  on(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */) { el.addEventListener(evt, listener, false); }
+  onAndCancel(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */): Function {
     el.addEventListener(evt, listener, false);
     // Needed to follow Dart's subscription semantic, until fix of
     // https://code.google.com/p/dart/issues/detail?id=17406
     return () => { el.removeEventListener(evt, listener, false); };
   }
-  dispatchEvent(el, evt) { el.dispatchEvent(evt); }
+  dispatchEvent(el: any /** TODO #9100 */, evt: any /** TODO #9100 */) { el.dispatchEvent(evt); }
   createMouseEvent(eventType: string): MouseEvent {
     var evt: MouseEvent = document.createEvent('MouseEvent');
     evt.initEvent(eventType, true, true);
     return evt;
   }
-  createEvent(eventType): Event {
+  createEvent(eventType: any /** TODO #9100 */): Event {
     var evt: Event = document.createEvent('Event');
     evt.initEvent(eventType, true, true);
     return evt;
@@ -123,11 +123,11 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   isPrevented(evt: Event): boolean {
     return evt.defaultPrevented || isPresent(evt.returnValue) && !evt.returnValue;
   }
-  getInnerHTML(el): string { return el.innerHTML; }
-  getTemplateContent(el): Node {
+  getInnerHTML(el: any /** TODO #9100 */): string { return el.innerHTML; }
+  getTemplateContent(el: any /** TODO #9100 */): Node {
     return 'content' in el && el instanceof HTMLTemplateElement ? el.content : null;
   }
-  getOuterHTML(el): string { return el.outerHTML; }
+  getOuterHTML(el: any /** TODO #9100 */): string { return el.outerHTML; }
   nodeName(node: Node): string { return node.nodeName; }
   nodeValue(node: Node): string { return node.nodeValue; }
   type(node: HTMLInputElement): string { return node.type; }
@@ -138,11 +138,11 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
       return node;
     }
   }
-  firstChild(el): Node { return el.firstChild; }
-  nextSibling(el): Node { return el.nextSibling; }
-  parentElement(el): Node { return el.parentNode; }
-  childNodes(el): Node[] { return el.childNodes; }
-  childNodesAsList(el): any[] {
+  firstChild(el: any /** TODO #9100 */): Node { return el.firstChild; }
+  nextSibling(el: any /** TODO #9100 */): Node { return el.nextSibling; }
+  parentElement(el: any /** TODO #9100 */): Node { return el.parentNode; }
+  childNodes(el: any /** TODO #9100 */): Node[] { return el.childNodes; }
+  childNodesAsList(el: any /** TODO #9100 */): any[] {
     var childNodes = el.childNodes;
     var res = ListWrapper.createFixedSize(childNodes.length);
     for (var i = 0; i < childNodes.length; i++) {
@@ -150,39 +150,39 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
     }
     return res;
   }
-  clearNodes(el) {
+  clearNodes(el: any /** TODO #9100 */) {
     while (el.firstChild) {
       el.removeChild(el.firstChild);
     }
   }
-  appendChild(el, node) { el.appendChild(node); }
-  removeChild(el, node) { el.removeChild(node); }
-  replaceChild(el: Node, newChild, oldChild) { el.replaceChild(newChild, oldChild); }
-  remove(node): Node {
+  appendChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { el.appendChild(node); }
+  removeChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { el.removeChild(node); }
+  replaceChild(el: Node, newChild: any /** TODO #9100 */, oldChild: any /** TODO #9100 */) { el.replaceChild(newChild, oldChild); }
+  remove(node: any /** TODO #9100 */): Node {
     if (node.parentNode) {
       node.parentNode.removeChild(node);
     }
     return node;
   }
-  insertBefore(el, node) { el.parentNode.insertBefore(node, el); }
-  insertAllBefore(el, nodes) { nodes.forEach(n => el.parentNode.insertBefore(n, el)); }
-  insertAfter(el, node) { el.parentNode.insertBefore(node, el.nextSibling); }
-  setInnerHTML(el, value) { el.innerHTML = value; }
-  getText(el): string { return el.textContent; }
+  insertBefore(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { el.parentNode.insertBefore(node, el); }
+  insertAllBefore(el: any /** TODO #9100 */, nodes: any /** TODO #9100 */) { nodes.forEach((n: any /** TODO #9100 */) => el.parentNode.insertBefore(n, el)); }
+  insertAfter(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { el.parentNode.insertBefore(node, el.nextSibling); }
+  setInnerHTML(el: any /** TODO #9100 */, value: any /** TODO #9100 */) { el.innerHTML = value; }
+  getText(el: any /** TODO #9100 */): string { return el.textContent; }
   // TODO(vicb): removed Element type because it does not support StyleElement
-  setText(el, value: string) { el.textContent = value; }
-  getValue(el): string { return el.value; }
-  setValue(el, value: string) { el.value = value; }
-  getChecked(el): boolean { return el.checked; }
-  setChecked(el, value: boolean) { el.checked = value; }
+  setText(el: any /** TODO #9100 */, value: string) { el.textContent = value; }
+  getValue(el: any /** TODO #9100 */): string { return el.value; }
+  setValue(el: any /** TODO #9100 */, value: string) { el.value = value; }
+  getChecked(el: any /** TODO #9100 */): boolean { return el.checked; }
+  setChecked(el: any /** TODO #9100 */, value: boolean) { el.checked = value; }
   createComment(text: string): Comment { return document.createComment(text); }
-  createTemplate(html): HTMLElement {
+  createTemplate(html: any /** TODO #9100 */): HTMLElement {
     var t = document.createElement('template');
     t.innerHTML = html;
     return t;
   }
-  createElement(tagName, doc = document): HTMLElement { return doc.createElement(tagName); }
-  createElementNS(ns, tagName, doc = document): Element { return doc.createElementNS(ns, tagName); }
+  createElement(tagName: any /** TODO #9100 */, doc = document): HTMLElement { return doc.createElement(tagName); }
+  createElementNS(ns: any /** TODO #9100 */, tagName: any /** TODO #9100 */, doc = document): Element { return doc.createElementNS(ns, tagName); }
   createTextNode(text: string, doc = document): Text { return doc.createTextNode(text); }
   createScriptTag(attrName: string, attrValue: string, doc = document): HTMLScriptElement {
     var el = <HTMLScriptElement>doc.createElement('SCRIPT');
@@ -198,27 +198,27 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   getShadowRoot(el: HTMLElement): DocumentFragment { return (<any>el).shadowRoot; }
   getHost(el: HTMLElement): HTMLElement { return (<any>el).host; }
   clone(node: Node): Node { return node.cloneNode(true); }
-  getElementsByClassName(element, name: string): HTMLElement[] {
+  getElementsByClassName(element: any /** TODO #9100 */, name: string): HTMLElement[] {
     return element.getElementsByClassName(name);
   }
-  getElementsByTagName(element, name: string): HTMLElement[] {
+  getElementsByTagName(element: any /** TODO #9100 */, name: string): HTMLElement[] {
     return element.getElementsByTagName(name);
   }
-  classList(element): any[] { return <any[]>Array.prototype.slice.call(element.classList, 0); }
-  addClass(element, className: string) { element.classList.add(className); }
-  removeClass(element, className: string) { element.classList.remove(className); }
-  hasClass(element, className: string): boolean { return element.classList.contains(className); }
-  setStyle(element, styleName: string, styleValue: string) {
+  classList(element: any /** TODO #9100 */): any[] { return <any[]>Array.prototype.slice.call(element.classList, 0); }
+  addClass(element: any /** TODO #9100 */, className: string) { element.classList.add(className); }
+  removeClass(element: any /** TODO #9100 */, className: string) { element.classList.remove(className); }
+  hasClass(element: any /** TODO #9100 */, className: string): boolean { return element.classList.contains(className); }
+  setStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string) {
     element.style[styleName] = styleValue;
   }
-  removeStyle(element, stylename: string) { element.style[stylename] = null; }
-  getStyle(element, stylename: string): string { return element.style[stylename]; }
-  hasStyle(element, styleName: string, styleValue: string = null): boolean {
+  removeStyle(element: any /** TODO #9100 */, stylename: string) { element.style[stylename] = null; }
+  getStyle(element: any /** TODO #9100 */, stylename: string): string { return element.style[stylename]; }
+  hasStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string = null): boolean {
     var value = this.getStyle(element, styleName) || '';
     return styleValue ? value == styleValue : value.length > 0;
   }
-  tagName(element): string { return element.tagName; }
-  attributeMap(element): Map<string, string> {
+  tagName(element: any /** TODO #9100 */): string { return element.tagName; }
+  attributeMap(element: any /** TODO #9100 */): Map<string, string> {
     var res = new Map<string, string>();
     var elAttrs = element.attributes;
     for (var i = 0; i < elAttrs.length; i++) {
@@ -227,26 +227,26 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
     }
     return res;
   }
-  hasAttribute(element, attribute: string): boolean { return element.hasAttribute(attribute); }
-  hasAttributeNS(element, ns: string, attribute: string): boolean {
+  hasAttribute(element: any /** TODO #9100 */, attribute: string): boolean { return element.hasAttribute(attribute); }
+  hasAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): boolean {
     return element.hasAttributeNS(ns, attribute);
   }
-  getAttribute(element, attribute: string): string { return element.getAttribute(attribute); }
-  getAttributeNS(element, ns: string, name: string): string {
+  getAttribute(element: any /** TODO #9100 */, attribute: string): string { return element.getAttribute(attribute); }
+  getAttributeNS(element: any /** TODO #9100 */, ns: string, name: string): string {
     return element.getAttributeNS(ns, name);
   }
-  setAttribute(element, name: string, value: string) { element.setAttribute(name, value); }
-  setAttributeNS(element, ns: string, name: string, value: string) {
+  setAttribute(element: any /** TODO #9100 */, name: string, value: string) { element.setAttribute(name, value); }
+  setAttributeNS(element: any /** TODO #9100 */, ns: string, name: string, value: string) {
     element.setAttributeNS(ns, name, value);
   }
-  removeAttribute(element, attribute: string) { element.removeAttribute(attribute); }
-  removeAttributeNS(element, ns: string, name: string) { element.removeAttributeNS(ns, name); }
-  templateAwareRoot(el): any { return this.isTemplateElement(el) ? this.content(el) : el; }
+  removeAttribute(element: any /** TODO #9100 */, attribute: string) { element.removeAttribute(attribute); }
+  removeAttributeNS(element: any /** TODO #9100 */, ns: string, name: string) { element.removeAttributeNS(ns, name); }
+  templateAwareRoot(el: any /** TODO #9100 */): any { return this.isTemplateElement(el) ? this.content(el) : el; }
   createHtmlDocument(): HTMLDocument {
     return document.implementation.createHTMLDocument('fakeTitle');
   }
   defaultDoc(): HTMLDocument { return document; }
-  getBoundingClientRect(el): any {
+  getBoundingClientRect(el: any /** TODO #9100 */): any {
     try {
       return el.getBoundingClientRect();
     } catch (e) {
@@ -255,7 +255,7 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   }
   getTitle(): string { return document.title; }
   setTitle(newTitle: string) { document.title = newTitle || ''; }
-  elementMatches(n, selector: string): boolean {
+  elementMatches(n: any /** TODO #9100 */, selector: string): boolean {
     var matches = false;
     if (n instanceof HTMLElement) {
       if (n.matches) {
@@ -274,8 +274,8 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   isTextNode(node: Node): boolean { return node.nodeType === Node.TEXT_NODE; }
   isCommentNode(node: Node): boolean { return node.nodeType === Node.COMMENT_NODE; }
   isElementNode(node: Node): boolean { return node.nodeType === Node.ELEMENT_NODE; }
-  hasShadowRoot(node): boolean { return node instanceof HTMLElement && isPresent(node.shadowRoot); }
-  isShadowRoot(node): boolean { return node instanceof DocumentFragment; }
+  hasShadowRoot(node: any /** TODO #9100 */): boolean { return node instanceof HTMLElement && isPresent(node.shadowRoot); }
+  isShadowRoot(node: any /** TODO #9100 */): boolean { return node instanceof DocumentFragment; }
   importIntoDoc(node: Node): any {
     var toImport = node;
     if (this.isTemplateElement(node)) {
@@ -285,7 +285,7 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   }
   adoptNode(node: Node): any { return document.adoptNode(node); }
   getHref(el: Element): string { return (<any>el).href; }
-  getEventKey(event): string {
+  getEventKey(event: any /** TODO #9100 */): string {
     var key = event.key;
     if (isBlank(key)) {
       key = event.keyIdentifier;
@@ -302,12 +302,12 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
           // There is a bug in Chrome for numeric keypad keys:
           // https://code.google.com/p/chromium/issues/detail?id=155654
           // 1, 2, 3 ... are reported as A, B, C ...
-          key = _chromeNumKeyPadMap[key];
+          key = (_chromeNumKeyPadMap as any /** TODO #9100 */)[key];
         }
       }
     }
     if (_keyMap.hasOwnProperty(key)) {
-      key = _keyMap[key];
+      key = (_keyMap as any /** TODO #9100 */)[key];
     }
     return key;
   }
@@ -331,16 +331,16 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
   }
   resetBaseElement(): void { baseElement = null; }
   getUserAgent(): string { return window.navigator.userAgent; }
-  setData(element, name: string, value: string) {
+  setData(element: any /** TODO #9100 */, name: string, value: string) {
     this.setAttribute(element, 'data-' + name, value);
   }
-  getData(element, name: string): string { return this.getAttribute(element, 'data-' + name); }
-  getComputedStyle(element): any { return getComputedStyle(element); }
+  getData(element: any /** TODO #9100 */, name: string): string { return this.getAttribute(element, 'data-' + name); }
+  getComputedStyle(element: any /** TODO #9100 */): any { return getComputedStyle(element); }
   // TODO(tbosch): move this into a separate environment class once we have it
   setGlobalVar(path: string, value: any) { setValueOnPath(global, path, value); }
-  requestAnimationFrame(callback): number { return window.requestAnimationFrame(callback); }
+  requestAnimationFrame(callback: any /** TODO #9100 */): number { return window.requestAnimationFrame(callback); }
   cancelAnimationFrame(id: number) { window.cancelAnimationFrame(id); }
-  supportsWebAnimation(): boolean { return isFunction(document.body['animate']); }
+  supportsWebAnimation(): boolean { return isFunction((document as any /** TODO #9100 */).body['animate']); }
   performanceNow(): number {
     // performance.now() is not available in all browsers, see
     // http://caniuse.com/#search=performance.now
@@ -365,7 +365,7 @@ export class BrowserDomAdapter extends GenericBrowserDomAdapter {
 }
 
 
-var baseElement = null;
+var baseElement: any /** TODO #9100 */ = null;
 function getBaseElementHref(): string {
   if (isBlank(baseElement)) {
     baseElement = document.querySelector('base');
@@ -377,8 +377,8 @@ function getBaseElementHref(): string {
 }
 
 // based on urlUtils.js in AngularJS 1
-var urlParsingNode = null;
-function relativePath(url): string {
+var urlParsingNode: any /** TODO #9100 */ = null;
+function relativePath(url: any /** TODO #9100 */): string {
   if (isBlank(urlParsingNode)) {
     urlParsingNode = document.createElement("a");
   }
diff --git a/modules/@angular/platform-browser/src/browser/testability.ts b/modules/@angular/platform-browser/src/browser/testability.ts
index 8f24369048..f14283bb71 100644
--- a/modules/@angular/platform-browser/src/browser/testability.ts
+++ b/modules/@angular/platform-browser/src/browser/testability.ts
@@ -50,18 +50,18 @@ export class BrowserGetTestability implements GetTestability {
 
     global.getAllAngularRootElements = () => registry.getAllRootElements();
 
-    var whenAllStable = (callback) => {
+    var whenAllStable = (callback: any /** TODO #9100 */) => {
       var testabilities = global.getAllAngularTestabilities();
       var count = testabilities.length;
       var didWork = false;
-      var decrement = function(didWork_) {
+      var decrement = function(didWork_: any /** TODO #9100 */) {
         didWork = didWork || didWork_;
         count--;
         if (count == 0) {
           callback(didWork);
         }
       };
-      testabilities.forEach(function(testability) { testability.whenStable(decrement); });
+      testabilities.forEach(function(testability: any /** TODO #9100 */) { testability.whenStable(decrement); });
     };
 
     if (!global.frameworkStabilizers) {
diff --git a/modules/@angular/platform-browser/src/dom/debug/ng_probe.ts b/modules/@angular/platform-browser/src/dom/debug/ng_probe.ts
index bd5add49c3..0929395cfa 100644
--- a/modules/@angular/platform-browser/src/dom/debug/ng_probe.ts
+++ b/modules/@angular/platform-browser/src/dom/debug/ng_probe.ts
@@ -21,18 +21,18 @@ const CORE_TOKENS_GLOBAL_NAME = 'ng.coreTokens';
  * null if the given native element does not have an Angular view associated
  * with it.
  */
-export function inspectNativeElement(element): DebugNode {
+export function inspectNativeElement(element: any /** TODO #9100 */): DebugNode {
   return getDebugNode(element);
 }
 
-function _createConditionalRootRenderer(rootRenderer) {
+function _createConditionalRootRenderer(rootRenderer: any /** TODO #9100 */) {
   if (assertionsEnabled()) {
     return _createRootRenderer(rootRenderer);
   }
   return rootRenderer;
 }
 
-function _createRootRenderer(rootRenderer) {
+function _createRootRenderer(rootRenderer: any /** TODO #9100 */) {
   getDOM().setGlobalVar(INSPECT_GLOBAL_NAME, inspectNativeElement);
   getDOM().setGlobalVar(CORE_TOKENS_GLOBAL_NAME, CORE_TOKENS);
   return new DebugDomRootRenderer(rootRenderer);
diff --git a/modules/@angular/platform-browser/src/dom/dom_adapter.ts b/modules/@angular/platform-browser/src/dom/dom_adapter.ts
index de8e29c536..1d818f9447 100644
--- a/modules/@angular/platform-browser/src/dom/dom_adapter.ts
+++ b/modules/@angular/platform-browser/src/dom/dom_adapter.ts
@@ -22,15 +22,15 @@ export function setRootDomAdapter(adapter: DomAdapter) {
  */
 export abstract class DomAdapter {
   public xhrType: Type = null;
-  abstract hasProperty(element, name: string): boolean;
-  abstract setProperty(el: Element, name: string, value: any);
+  abstract hasProperty(element: any /** TODO #9100 */, name: string): boolean;
+  abstract setProperty(el: Element, name: string, value: any): any /** TODO #9100 */;
   abstract getProperty(el: Element, name: string): any;
   abstract invoke(el: Element, methodName: string, args: any[]): any;
 
-  abstract logError(error);
-  abstract log(error);
-  abstract logGroup(error);
-  abstract logGroupEnd();
+  abstract logError(error: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract log(error: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract logGroup(error: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract logGroupEnd(): any /** TODO #9100 */;
 
   /** @deprecated */
   getXHR(): Type { return this.xhrType; }
@@ -44,95 +44,95 @@ export abstract class DomAdapter {
   /** @internal */
   _attrToPropMap: {[key: string]: string};
 
-  abstract parse(templateHtml: string);
+  abstract parse(templateHtml: string): any /** TODO #9100 */;
   abstract query(selector: string): any;
-  abstract querySelector(el, selector: string): HTMLElement;
-  abstract querySelectorAll(el, selector: string): any[];
-  abstract on(el, evt, listener);
-  abstract onAndCancel(el, evt, listener): Function;
-  abstract dispatchEvent(el, evt);
-  abstract createMouseEvent(eventType): any;
+  abstract querySelector(el: any /** TODO #9100 */, selector: string): HTMLElement;
+  abstract querySelectorAll(el: any /** TODO #9100 */, selector: string): any[];
+  abstract on(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract onAndCancel(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */): Function;
+  abstract dispatchEvent(el: any /** TODO #9100 */, evt: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract createMouseEvent(eventType: any /** TODO #9100 */): any;
   abstract createEvent(eventType: string): any;
-  abstract preventDefault(evt);
-  abstract isPrevented(evt): boolean;
-  abstract getInnerHTML(el): string;
+  abstract preventDefault(evt: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract isPrevented(evt: any /** TODO #9100 */): boolean;
+  abstract getInnerHTML(el: any /** TODO #9100 */): string;
   /** Returns content if el is a <template> element, null otherwise. */
-  abstract getTemplateContent(el): any;
-  abstract getOuterHTML(el): string;
-  abstract nodeName(node): string;
-  abstract nodeValue(node): string;
-  abstract type(node): string;
-  abstract content(node): any;
-  abstract firstChild(el): Node;
-  abstract nextSibling(el): Node;
-  abstract parentElement(el): Node;
-  abstract childNodes(el): Node[];
-  abstract childNodesAsList(el): Node[];
-  abstract clearNodes(el);
-  abstract appendChild(el, node);
-  abstract removeChild(el, node);
-  abstract replaceChild(el, newNode, oldNode);
-  abstract remove(el): Node;
-  abstract insertBefore(el, node);
-  abstract insertAllBefore(el, nodes);
-  abstract insertAfter(el, node);
-  abstract setInnerHTML(el, value);
-  abstract getText(el): string;
-  abstract setText(el, value: string);
-  abstract getValue(el): string;
-  abstract setValue(el, value: string);
-  abstract getChecked(el): boolean;
-  abstract setChecked(el, value: boolean);
+  abstract getTemplateContent(el: any /** TODO #9100 */): any;
+  abstract getOuterHTML(el: any /** TODO #9100 */): string;
+  abstract nodeName(node: any /** TODO #9100 */): string;
+  abstract nodeValue(node: any /** TODO #9100 */): string;
+  abstract type(node: any /** TODO #9100 */): string;
+  abstract content(node: any /** TODO #9100 */): any;
+  abstract firstChild(el: any /** TODO #9100 */): Node;
+  abstract nextSibling(el: any /** TODO #9100 */): Node;
+  abstract parentElement(el: any /** TODO #9100 */): Node;
+  abstract childNodes(el: any /** TODO #9100 */): Node[];
+  abstract childNodesAsList(el: any /** TODO #9100 */): Node[];
+  abstract clearNodes(el: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract appendChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract removeChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract replaceChild(el: any /** TODO #9100 */, newNode: any /** TODO #9100 */, oldNode: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract remove(el: any /** TODO #9100 */): Node;
+  abstract insertBefore(el: any /** TODO #9100 */, node: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract insertAllBefore(el: any /** TODO #9100 */, nodes: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract insertAfter(el: any /** TODO #9100 */, node: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract setInnerHTML(el: any /** TODO #9100 */, value: any /** TODO #9100 */): any /** TODO #9100 */;
+  abstract getText(el: any /** TODO #9100 */): string;
+  abstract setText(el: any /** TODO #9100 */, value: string): any /** TODO #9100 */;
+  abstract getValue(el: any /** TODO #9100 */): string;
+  abstract setValue(el: any /** TODO #9100 */, value: string): any /** TODO #9100 */;
+  abstract getChecked(el: any /** TODO #9100 */): boolean;
+  abstract setChecked(el: any /** TODO #9100 */, value: boolean): any /** TODO #9100 */;
   abstract createComment(text: string): any;
-  abstract createTemplate(html): HTMLElement;
-  abstract createElement(tagName, doc?): HTMLElement;
-  abstract createElementNS(ns: string, tagName: string, doc?): Element;
-  abstract createTextNode(text: string, doc?): Text;
-  abstract createScriptTag(attrName: string, attrValue: string, doc?): HTMLElement;
-  abstract createStyleElement(css: string, doc?): HTMLStyleElement;
-  abstract createShadowRoot(el): any;
-  abstract getShadowRoot(el): any;
-  abstract getHost(el): any;
-  abstract getDistributedNodes(el): Node[];
+  abstract createTemplate(html: any /** TODO #9100 */): HTMLElement;
+  abstract createElement(tagName: any /** TODO #9100 */, doc?: any /** TODO #9100 */): HTMLElement;
+  abstract createElementNS(ns: string, tagName: string, doc?: any /** TODO #9100 */): Element;
+  abstract createTextNode(text: string, doc?: any /** TODO #9100 */): Text;
+  abstract createScriptTag(attrName: string, attrValue: string, doc?: any /** TODO #9100 */): HTMLElement;
+  abstract createStyleElement(css: string, doc?: any /** TODO #9100 */): HTMLStyleElement;
+  abstract createShadowRoot(el: any /** TODO #9100 */): any;
+  abstract getShadowRoot(el: any /** TODO #9100 */): any;
+  abstract getHost(el: any /** TODO #9100 */): any;
+  abstract getDistributedNodes(el: any /** TODO #9100 */): Node[];
   abstract clone /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
-  abstract getElementsByClassName(element, name: string): HTMLElement[];
-  abstract getElementsByTagName(element, name: string): HTMLElement[];
-  abstract classList(element): any[];
-  abstract addClass(element, className: string);
-  abstract removeClass(element, className: string);
-  abstract hasClass(element, className: string): boolean;
-  abstract setStyle(element, styleName: string, styleValue: string);
-  abstract removeStyle(element, styleName: string);
-  abstract getStyle(element, styleName: string): string;
-  abstract hasStyle(element, styleName: string, styleValue?: string): boolean;
-  abstract tagName(element): string;
-  abstract attributeMap(element): Map<string, string>;
-  abstract hasAttribute(element, attribute: string): boolean;
-  abstract hasAttributeNS(element, ns: string, attribute: string): boolean;
-  abstract getAttribute(element, attribute: string): string;
-  abstract getAttributeNS(element, ns: string, attribute: string): string;
-  abstract setAttribute(element, name: string, value: string);
-  abstract setAttributeNS(element, ns: string, name: string, value: string);
-  abstract removeAttribute(element, attribute: string);
-  abstract removeAttributeNS(element, ns: string, attribute: string);
-  abstract templateAwareRoot(el);
+  abstract getElementsByClassName(element: any /** TODO #9100 */, name: string): HTMLElement[];
+  abstract getElementsByTagName(element: any /** TODO #9100 */, name: string): HTMLElement[];
+  abstract classList(element: any /** TODO #9100 */): any[];
+  abstract addClass(element: any /** TODO #9100 */, className: string): any /** TODO #9100 */;
+  abstract removeClass(element: any /** TODO #9100 */, className: string): any /** TODO #9100 */;
+  abstract hasClass(element: any /** TODO #9100 */, className: string): boolean;
+  abstract setStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string): any /** TODO #9100 */;
+  abstract removeStyle(element: any /** TODO #9100 */, styleName: string): any /** TODO #9100 */;
+  abstract getStyle(element: any /** TODO #9100 */, styleName: string): string;
+  abstract hasStyle(element: any /** TODO #9100 */, styleName: string, styleValue?: string): boolean;
+  abstract tagName(element: any /** TODO #9100 */): string;
+  abstract attributeMap(element: any /** TODO #9100 */): Map<string, string>;
+  abstract hasAttribute(element: any /** TODO #9100 */, attribute: string): boolean;
+  abstract hasAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): boolean;
+  abstract getAttribute(element: any /** TODO #9100 */, attribute: string): string;
+  abstract getAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): string;
+  abstract setAttribute(element: any /** TODO #9100 */, name: string, value: string): any /** TODO #9100 */;
+  abstract setAttributeNS(element: any /** TODO #9100 */, ns: string, name: string, value: string): any /** TODO #9100 */;
+  abstract removeAttribute(element: any /** TODO #9100 */, attribute: string): any /** TODO #9100 */;
+  abstract removeAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): any /** TODO #9100 */;
+  abstract templateAwareRoot(el: any /** TODO #9100 */): any /** TODO #9100 */;
   abstract createHtmlDocument(): HTMLDocument;
   abstract defaultDoc(): HTMLDocument;
-  abstract getBoundingClientRect(el);
+  abstract getBoundingClientRect(el: any /** TODO #9100 */): any /** TODO #9100 */;
   abstract getTitle(): string;
-  abstract setTitle(newTitle: string);
-  abstract elementMatches(n, selector: string): boolean;
+  abstract setTitle(newTitle: string): any /** TODO #9100 */;
+  abstract elementMatches(n: any /** TODO #9100 */, selector: string): boolean;
   abstract isTemplateElement(el: any): boolean;
-  abstract isTextNode(node): boolean;
-  abstract isCommentNode(node): boolean;
-  abstract isElementNode(node): boolean;
-  abstract hasShadowRoot(node): boolean;
-  abstract isShadowRoot(node): boolean;
+  abstract isTextNode(node: any /** TODO #9100 */): boolean;
+  abstract isCommentNode(node: any /** TODO #9100 */): boolean;
+  abstract isElementNode(node: any /** TODO #9100 */): boolean;
+  abstract hasShadowRoot(node: any /** TODO #9100 */): boolean;
+  abstract isShadowRoot(node: any /** TODO #9100 */): boolean;
   abstract importIntoDoc /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
   abstract adoptNode /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
-  abstract getHref(element): string;
-  abstract getEventKey(event): string;
-  abstract resolveAndSetHref(element, baseUrl: string, href: string);
+  abstract getHref(element: any /** TODO #9100 */): string;
+  abstract getEventKey(event: any /** TODO #9100 */): string;
+  abstract resolveAndSetHref(element: any /** TODO #9100 */, baseUrl: string, href: string): any /** TODO #9100 */;
   abstract supportsDOMEvents(): boolean;
   abstract supportsNativeShadowDOM(): boolean;
   abstract getGlobalEventTarget(target: string): any;
@@ -141,12 +141,12 @@ export abstract class DomAdapter {
   abstract getBaseHref(): string;
   abstract resetBaseElement(): void;
   abstract getUserAgent(): string;
-  abstract setData(element, name: string, value: string);
-  abstract getComputedStyle(element): any;
-  abstract getData(element, name: string): string;
-  abstract setGlobalVar(name: string, value: any);
-  abstract requestAnimationFrame(callback): number;
-  abstract cancelAnimationFrame(id);
+  abstract setData(element: any /** TODO #9100 */, name: string, value: string): any /** TODO #9100 */;
+  abstract getComputedStyle(element: any /** TODO #9100 */): any;
+  abstract getData(element: any /** TODO #9100 */, name: string): string;
+  abstract setGlobalVar(name: string, value: any): any /** TODO #9100 */;
+  abstract requestAnimationFrame(callback: any /** TODO #9100 */): number;
+  abstract cancelAnimationFrame(id: any /** TODO #9100 */): any /** TODO #9100 */;
   abstract supportsWebAnimation(): boolean;
   abstract performanceNow(): number;
   abstract getAnimationPrefix(): string;
@@ -155,5 +155,5 @@ export abstract class DomAdapter {
 
   abstract supportsCookies(): boolean;
   abstract getCookie(name: string): string;
-  abstract setCookie(name: string, value: string);
+  abstract setCookie(name: string, value: string): any /** TODO #9100 */;
 }
diff --git a/modules/@angular/platform-browser/src/dom/dom_renderer.ts b/modules/@angular/platform-browser/src/dom/dom_renderer.ts
index de25c9bd71..5dc4e609c5 100644
--- a/modules/@angular/platform-browser/src/dom/dom_renderer.ts
+++ b/modules/@angular/platform-browser/src/dom/dom_renderer.ts
@@ -88,7 +88,7 @@ export class DomRenderer implements Renderer {
   }
 
   selectRootElement(selectorOrNode: string | any, debugInfo: RenderDebugInfo): Element {
-    var el;
+    var el: any /** TODO #9100 */;
     if (isString(selectorOrNode)) {
       el = getDOM().querySelector(this._rootRenderer.document, selectorOrNode);
       if (isBlank(el)) {
@@ -104,7 +104,7 @@ export class DomRenderer implements Renderer {
   createElement(parent: Element, name: string, debugInfo: RenderDebugInfo): Node {
     var nsAndName = splitNamespace(name);
     var el = isPresent(nsAndName[0]) ?
-                 getDOM().createElementNS(NAMESPACE_URIS[nsAndName[0]], nsAndName[1]) :
+                 getDOM().createElementNS((NAMESPACE_URIS as any /** TODO #9100 */)[nsAndName[0]], nsAndName[1]) :
                  getDOM().createElement(nsAndName[1]);
     if (isPresent(this._contentAttr)) {
       getDOM().setAttribute(el, this._contentAttr, '');
@@ -116,7 +116,7 @@ export class DomRenderer implements Renderer {
   }
 
   createViewRoot(hostElement: any): any {
-    var nodesParent;
+    var nodesParent: any /** TODO #9100 */;
     if (this.componentProto.encapsulation === ViewEncapsulation.Native) {
       nodesParent = getDOM().createShadowRoot(hostElement);
       this._rootRenderer.sharedStylesHost.addHost(nodesParent);
@@ -184,11 +184,11 @@ export class DomRenderer implements Renderer {
   }
 
   setElementAttribute(renderElement: any, attributeName: string, attributeValue: string): void {
-    var attrNs;
+    var attrNs: any /** TODO #9100 */;
     var nsAndName = splitNamespace(attributeName);
     if (isPresent(nsAndName[0])) {
       attributeName = nsAndName[0] + ':' + nsAndName[1];
-      attrNs = NAMESPACE_URIS[nsAndName[0]];
+      attrNs = (NAMESPACE_URIS as any /** TODO #9100 */)[nsAndName[0]];
     }
     if (isPresent(attributeValue)) {
       if (isPresent(attrNs)) {
@@ -212,7 +212,7 @@ export class DomRenderer implements Renderer {
           TEMPLATE_BINDINGS_EXP,
           StringWrapper.replaceAll(getDOM().getText(renderElement), /\n/g, ''));
       var parsedBindings = Json.parse(existingBindings[1]);
-      parsedBindings[dashCasedPropertyName] = propertyValue;
+      (parsedBindings as any /** TODO #9100 */)[dashCasedPropertyName] = propertyValue;
       getDOM().setText(renderElement, StringWrapper.replace(TEMPLATE_COMMENT_TEXT, '{}',
                                                             Json.stringify(parsedBindings)));
     } else {
@@ -250,7 +250,7 @@ export class DomRenderer implements Renderer {
   }
 }
 
-function moveNodesAfterSibling(sibling, nodes) {
+function moveNodesAfterSibling(sibling: any /** TODO #9100 */, nodes: any /** TODO #9100 */) {
   var parent = getDOM().parentElement(sibling);
   if (nodes.length > 0 && isPresent(parent)) {
     var nextSibling = getDOM().nextSibling(sibling);
@@ -266,14 +266,14 @@ function moveNodesAfterSibling(sibling, nodes) {
   }
 }
 
-function appendNodes(parent, nodes) {
+function appendNodes(parent: any /** TODO #9100 */, nodes: any /** TODO #9100 */) {
   for (var i = 0; i < nodes.length; i++) {
     getDOM().appendChild(parent, nodes[i]);
   }
 }
 
 function decoratePreventDefault(eventHandler: Function): Function {
-  return (event) => {
+  return (event: any /** TODO #9100 */) => {
     var allowDefaultBehavior = eventHandler(event);
     if (allowDefaultBehavior === false) {
       // TODO(tbosch): move preventDefault into event plugins...
diff --git a/modules/@angular/platform-browser/src/dom/events/dom_events.ts b/modules/@angular/platform-browser/src/dom/events/dom_events.ts
index a6d39c2e09..27c6fd51f5 100644
--- a/modules/@angular/platform-browser/src/dom/events/dom_events.ts
+++ b/modules/@angular/platform-browser/src/dom/events/dom_events.ts
@@ -11,7 +11,7 @@ export class DomEventsPlugin extends EventManagerPlugin {
 
   addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
     var zone = this.manager.getZone();
-    var outsideHandler = (event) => zone.runGuarded(() => handler(event));
+    var outsideHandler = (event: any /** TODO #9100 */) => zone.runGuarded(() => handler(event));
     return this.manager.getZone().runOutsideAngular(
         () => getDOM().onAndCancel(element, eventName, outsideHandler));
   }
@@ -19,7 +19,7 @@ export class DomEventsPlugin extends EventManagerPlugin {
   addGlobalEventListener(target: string, eventName: string, handler: Function): Function {
     var element = getDOM().getGlobalEventTarget(target);
     var zone = this.manager.getZone();
-    var outsideHandler = (event) => zone.runGuarded(() => handler(event));
+    var outsideHandler = (event: any /** TODO #9100 */) => zone.runGuarded(() => handler(event));
     return this.manager.getZone().runOutsideAngular(
         () => getDOM().onAndCancel(element, eventName, outsideHandler));
   }
diff --git a/modules/@angular/platform-browser/src/dom/events/hammer_gestures.ts b/modules/@angular/platform-browser/src/dom/events/hammer_gestures.ts
index 42727d5919..730218bdc2 100644
--- a/modules/@angular/platform-browser/src/dom/events/hammer_gestures.ts
+++ b/modules/@angular/platform-browser/src/dom/events/hammer_gestures.ts
@@ -37,7 +37,7 @@ export class HammerGesturesPlugin extends HammerGesturesPluginCommon {
   supports(eventName: string): boolean {
     if (!super.supports(eventName) && !this.isCustomEvent(eventName)) return false;
 
-    if (!isPresent(window['Hammer'])) {
+    if (!isPresent((window as any /** TODO #???? */)['Hammer'])) {
       throw new BaseException(`Hammer.js is not loaded, can not bind ${eventName} event`);
     }
 
@@ -51,7 +51,7 @@ export class HammerGesturesPlugin extends HammerGesturesPluginCommon {
     return zone.runOutsideAngular(() => {
       // Creating the manager bind events, must be done outside of angular
       var mc = this._config.buildHammer(element);
-      var callback = function(eventObj) { zone.runGuarded(function() { handler(eventObj); }); };
+      var callback = function(eventObj: any /** TODO #???? */) { zone.runGuarded(function() { handler(eventObj); }); };
       mc.on(eventName, callback);
       return () => { mc.off(eventName, callback); };
     });
diff --git a/modules/@angular/platform-browser/src/dom/events/key_events.ts b/modules/@angular/platform-browser/src/dom/events/key_events.ts
index 4570fe766c..fc82fe81b7 100644
--- a/modules/@angular/platform-browser/src/dom/events/key_events.ts
+++ b/modules/@angular/platform-browser/src/dom/events/key_events.ts
@@ -91,7 +91,7 @@ export class KeyEventsPlugin extends EventManagerPlugin {
 
   static eventCallback(element: HTMLElement, fullKey: any, handler: Function,
                        zone: NgZone): Function {
-    return (event) => {
+    return (event: any /** TODO #9100 */) => {
       if (StringWrapper.equals(KeyEventsPlugin.getEventFullKey(event), fullKey)) {
         zone.runGuarded(() => handler(event));
       }
diff --git a/modules/@angular/platform-browser/src/dom/shared_styles_host.ts b/modules/@angular/platform-browser/src/dom/shared_styles_host.ts
index db2e62eab7..fff15e313b 100644
--- a/modules/@angular/platform-browser/src/dom/shared_styles_host.ts
+++ b/modules/@angular/platform-browser/src/dom/shared_styles_host.ts
@@ -14,7 +14,7 @@ export class SharedStylesHost {
   constructor() {}
 
   addStyles(styles: string[]) {
-    var additions = [];
+    var additions: any[] /** TODO #9100 */ = [];
     styles.forEach(style => {
       if (!SetWrapper.has(this._stylesSet, style)) {
         this._stylesSet.add(style);
diff --git a/modules/@angular/platform-browser/src/dom/util.ts b/modules/@angular/platform-browser/src/dom/util.ts
index 4de398cc98..cc225ac30d 100644
--- a/modules/@angular/platform-browser/src/dom/util.ts
+++ b/modules/@angular/platform-browser/src/dom/util.ts
@@ -6,10 +6,10 @@ var DASH_CASE_REGEXP = /-([a-z])/g;
 
 export function camelCaseToDashCase(input: string): string {
   return StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP,
-                                        (m) => { return '-' + m[1].toLowerCase(); });
+                                        (m: any /** TODO #9100 */) => { return '-' + m[1].toLowerCase(); });
 }
 
 export function dashCaseToCamelCase(input: string): string {
   return StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP,
-                                        (m) => { return m[1].toUpperCase(); });
+                                        (m: any /** TODO #9100 */) => { return m[1].toUpperCase(); });
 }
diff --git a/modules/@angular/platform-browser/src/dom/web_animations_driver.ts b/modules/@angular/platform-browser/src/dom/web_animations_driver.ts
index d05506d7b8..edf4ba0c39 100644
--- a/modules/@angular/platform-browser/src/dom/web_animations_driver.ts
+++ b/modules/@angular/platform-browser/src/dom/web_animations_driver.ts
@@ -20,7 +20,7 @@ export class WebAnimationsDriver implements AnimationDriver {
 
     var anyElm = <any>element;
 
-    var formattedSteps = [];
+    var formattedSteps: any[] /** TODO #9100 */ = [];
     var startingStyleLookup: {[key: string]: string|number}= {};
     if (isPresent(startingStyles) && startingStyles.styles.length > 0) {
       startingStyleLookup = _populateStyles(anyElm, startingStyles, {});
@@ -30,7 +30,7 @@ export class WebAnimationsDriver implements AnimationDriver {
 
     keyframes.forEach((keyframe: AnimationKeyframe) => {
       let data = _populateStyles(anyElm, keyframe.styles, startingStyleLookup);
-      data['offset'] = keyframe.offset;
+      (data as any /** TODO #9100 */)['offset'] = keyframe.offset;
       formattedSteps.push(data);
     });
 
@@ -55,15 +55,15 @@ export class WebAnimationsDriver implements AnimationDriver {
 function _populateStyles(element: any, styles: AnimationStyles, defaultStyles: {[key: string]: string|number}) {
   var data = {};
   styles.styles.forEach((entry) => {
-    StringMapWrapper.forEach(entry, (val, prop) => {
-      data[prop] = val == AUTO_STYLE
+    StringMapWrapper.forEach(entry, (val: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
+      (data as any /** TODO #9100 */)[prop] = val == AUTO_STYLE
           ? _computeStyle(element, prop)
           : val.toString() + _resolveStyleUnit(val, prop);
     });
   });
-  StringMapWrapper.forEach(defaultStyles, (value, prop) => {
-    if (!isPresent(data[prop])) {
-      data[prop] = value;
+  StringMapWrapper.forEach(defaultStyles, (value: any /** TODO #9100 */, prop: any /** TODO #9100 */) => {
+    if (!isPresent((data as any /** TODO #9100 */)[prop])) {
+      (data as any /** TODO #9100 */)[prop] = value;
     }
   });
   return data;
diff --git a/modules/@angular/platform-browser/src/dom/web_animations_player.ts b/modules/@angular/platform-browser/src/dom/web_animations_player.ts
index 9235ee6453..7e61854135 100644
--- a/modules/@angular/platform-browser/src/dom/web_animations_player.ts
+++ b/modules/@angular/platform-browser/src/dom/web_animations_player.ts
@@ -47,7 +47,7 @@ export class WebAnimationsPlayer implements AnimationPlayer {
     this._onFinish();
   }
 
-  setPosition(p): void {
+  setPosition(p: any /** TODO #9100 */): void {
     this._player.currentTime = p * this.totalTime;
   }
 
diff --git a/modules/@angular/platform-browser/src/security/dom_sanitization_service.ts b/modules/@angular/platform-browser/src/security/dom_sanitization_service.ts
index a5a4801d3b..cbe5adc997 100644
--- a/modules/@angular/platform-browser/src/security/dom_sanitization_service.ts
+++ b/modules/@angular/platform-browser/src/security/dom_sanitization_service.ts
@@ -93,7 +93,7 @@ export abstract class DomSanitizationService implements SanitizationService {
    *
    * WARNING: calling this method with untrusted user data will cause severe security bugs!
    */
-  abstract bypassSecurityTrustResourceUrl(value: string);
+  abstract bypassSecurityTrustResourceUrl(value: string): any /** TODO #9100 */;
 }
 
 
diff --git a/modules/@angular/platform-browser/src/security/html_sanitizer.ts b/modules/@angular/platform-browser/src/security/html_sanitizer.ts
index b386def69d..c52f0163d7 100644
--- a/modules/@angular/platform-browser/src/security/html_sanitizer.ts
+++ b/modules/@angular/platform-browser/src/security/html_sanitizer.ts
@@ -166,7 +166,7 @@ class SanitizingHtmlSerializer {
     }
   }
 
-  private chars(chars) { this.buf.push(encodeEntities(chars)); }
+  private chars(chars: any /** TODO #9100 */) { this.buf.push(encodeEntities(chars)); }
 }
 
 // Regular Expressions for parsing tags and attributes
@@ -181,16 +181,16 @@ const NON_ALPHANUMERIC_REGEXP = /([^\#-~ |!])/g;
  * @param value
  * @returns {string} escaped text
  */
-function encodeEntities(value) {
+function encodeEntities(value: any /** TODO #9100 */) {
   return value.replace(/&/g, '&amp;')
       .replace(SURROGATE_PAIR_REGEXP,
-               function(match) {
+               function(match: any /** TODO #9100 */) {
                  let hi = match.charCodeAt(0);
                  let low = match.charCodeAt(1);
                  return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
                })
       .replace(NON_ALPHANUMERIC_REGEXP,
-               function(match) { return '&#' + match.charCodeAt(0) + ';'; })
+               function(match: any /** TODO #9100 */) { return '&#' + match.charCodeAt(0) + ';'; })
       .replace(/</g, '&lt;')
       .replace(/>/g, '&gt;');
 }
diff --git a/modules/@angular/platform-browser/src/web_workers/shared/client_message_broker.ts b/modules/@angular/platform-browser/src/web_workers/shared/client_message_broker.ts
index ae0d2c1191..7521e8b720 100644
--- a/modules/@angular/platform-browser/src/web_workers/shared/client_message_broker.ts
+++ b/modules/@angular/platform-browser/src/web_workers/shared/client_message_broker.ts
@@ -45,7 +45,7 @@ export class ClientMessageBroker_ extends ClientMessageBroker {
   /** @internal */
   public _serializer: Serializer;
 
-  constructor(messageBus: MessageBus, _serializer: Serializer, public channel) {
+  constructor(messageBus: MessageBus, _serializer: Serializer, public channel: any /** TODO #9100 */) {
     super();
     this._sink = messageBus.to(channel);
     this._serializer = _serializer;
@@ -58,7 +58,7 @@ export class ClientMessageBroker_ extends ClientMessageBroker {
     var time: string = stringify(DateWrapper.toMillis(DateWrapper.now()));
     var iteration: number = 0;
     var id: string = name + time + stringify(iteration);
-    while (isPresent(this._pending[id])) {
+    while (isPresent((this as any /** TODO #9100 */)._pending[id])) {
       id = `${name}${time}${iteration}`;
       iteration++;
     }
@@ -66,7 +66,7 @@ export class ClientMessageBroker_ extends ClientMessageBroker {
   }
 
   runOnService(args: UiArguments, returnType: Type): Promise<any> {
-    var fnArgs = [];
+    var fnArgs: any[] /** TODO #9100 */ = [];
     if (isPresent(args.args)) {
       args.args.forEach(argument => {
         if (argument.type != null) {
@@ -102,7 +102,7 @@ export class ClientMessageBroker_ extends ClientMessageBroker {
     // TODO(jteplitz602): Create a class for these messages so we don't keep using StringMap #3685
     var message = {'method': args.method, 'args': fnArgs};
     if (id != null) {
-      message['id'] = id;
+      (message as any /** TODO #9100 */)['id'] = id;
     }
     ObservableWrapper.callEmit(this._sink, message);
 
@@ -151,7 +151,7 @@ class MessageData {
 }
 
 export class FnArg {
-  constructor(public value, public type: Type) {}
+  constructor(public value: any /** TODO #9100 */, public type: Type) {}
 }
 
 export class UiArguments {
diff --git a/modules/@angular/platform-browser/src/web_workers/shared/service_message_broker.ts b/modules/@angular/platform-browser/src/web_workers/shared/service_message_broker.ts
index 2aa3e5bcea..83b8b10657 100644
--- a/modules/@angular/platform-browser/src/web_workers/shared/service_message_broker.ts
+++ b/modules/@angular/platform-browser/src/web_workers/shared/service_message_broker.ts
@@ -43,7 +43,7 @@ export class ServiceMessageBroker_ extends ServiceMessageBroker {
   private _sink: EventEmitter<any>;
   private _methods: Map<string, Function> = new Map<string, Function>();
 
-  constructor(messageBus: MessageBus, private _serializer: Serializer, public channel) {
+  constructor(messageBus: MessageBus, private _serializer: Serializer, public channel: any /** TODO #9100 */) {
     super();
     this._sink = messageBus.to(channel);
     var source = messageBus.from(channel);
diff --git a/modules/@angular/platform-browser/src/web_workers/ui/event_dispatcher.ts b/modules/@angular/platform-browser/src/web_workers/ui/event_dispatcher.ts
index fdf7c600f2..67bb3a33d5 100644
--- a/modules/@angular/platform-browser/src/web_workers/ui/event_dispatcher.ts
+++ b/modules/@angular/platform-browser/src/web_workers/ui/event_dispatcher.ts
@@ -13,7 +13,7 @@ export class EventDispatcher {
   constructor(private _sink: EventEmitter<any>, private _serializer: Serializer) {}
 
   dispatchRenderEvent(element: any, eventTarget: string, eventName: string, event: any): boolean {
-    var serializedEvent;
+    var serializedEvent: any /** TODO #9100 */;
     // TODO (jteplitz602): support custom events #3350
     switch (event.type) {
       case "click":
diff --git a/modules/@angular/platform-browser/src/web_workers/ui/event_serializer.ts b/modules/@angular/platform-browser/src/web_workers/ui/event_serializer.ts
index 6d3e0c2646..07d6f49719 100644
--- a/modules/@angular/platform-browser/src/web_workers/ui/event_serializer.ts
+++ b/modules/@angular/platform-browser/src/web_workers/ui/event_serializer.ts
@@ -80,7 +80,7 @@ function serializeEvent(e: any, properties: string[]): {[key: string]: any} {
   var serialized = {};
   for (var i = 0; i < properties.length; i++) {
     var prop = properties[i];
-    serialized[prop] = e[prop];
+    (serialized as any /** TODO #9100 */)[prop] = e[prop];
   }
   return serialized;
 }
diff --git a/modules/@angular/platform-browser/src/web_workers/ui/renderer.ts b/modules/@angular/platform-browser/src/web_workers/ui/renderer.ts
index f7269225dd..4e7b967bfb 100644
--- a/modules/@angular/platform-browser/src/web_workers/ui/renderer.ts
+++ b/modules/@angular/platform-browser/src/web_workers/ui/renderer.ts
@@ -155,7 +155,7 @@ export class MessageBasedRenderer {
 
   private _listen(renderer: Renderer, renderElement: any, eventName: string, unlistenId: number) {
     var unregisterCallback = renderer.listen(renderElement, eventName,
-                                             (event) => this._eventDispatcher.dispatchRenderEvent(
+                                             (event: any /** TODO #9100 */) => this._eventDispatcher.dispatchRenderEvent(
                                                  renderElement, null, eventName, event));
     this._renderStore.store(unregisterCallback, unlistenId);
   }
@@ -164,7 +164,7 @@ export class MessageBasedRenderer {
                         unlistenId: number) {
     var unregisterCallback = renderer.listenGlobal(
         eventTarget, eventName,
-        (event) => this._eventDispatcher.dispatchRenderEvent(null, eventTarget, eventName, event));
+        (event: any /** TODO #9100 */) => this._eventDispatcher.dispatchRenderEvent(null, eventTarget, eventName, event));
     this._renderStore.store(unregisterCallback, unlistenId);
   }
 
diff --git a/modules/@angular/platform-browser/src/web_workers/worker/renderer.ts b/modules/@angular/platform-browser/src/web_workers/worker/renderer.ts
index f402fb313b..1884b91222 100644
--- a/modules/@angular/platform-browser/src/web_workers/worker/renderer.ts
+++ b/modules/@angular/platform-browser/src/web_workers/worker/renderer.ts
@@ -20,7 +20,7 @@ import {AnimationKeyframe, AnimationPlayer, AnimationStyles, RenderDebugInfo} fr
 
 @Injectable()
 export class WebWorkerRootRenderer implements RootRenderer {
-  private _messageBroker;
+  private _messageBroker: any /** TODO #9100 */;
   public globalEvents: NamedEventEmitter = new NamedEventEmitter();
   private _componentRenderers: Map<string, WebWorkerRenderer> =
       new Map<string, WebWorkerRenderer>();
diff --git a/modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.ts b/modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.ts
index 58868e26e5..f5ab6fe544 100644
--- a/modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.ts
+++ b/modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.ts
@@ -9,7 +9,7 @@ import {DomAdapter, setRootDomAdapter} from '../../dom/dom_adapter';
 export class WorkerDomAdapter extends DomAdapter {
   static makeCurrent() { setRootDomAdapter(new WorkerDomAdapter()); }
 
-  logError(error) {
+  logError(error: any /** TODO #9100 */) {
     if (console.error) {
       console.error(error);
     } else {
@@ -17,9 +17,9 @@ export class WorkerDomAdapter extends DomAdapter {
     }
   }
 
-  log(error) { console.log(error); }
+  log(error: any /** TODO #9100 */) { console.log(error); }
 
-  logGroup(error) {
+  logGroup(error: any /** TODO #9100 */) {
     if (console.group) {
       console.group(error);
       this.logError(error);
@@ -34,7 +34,7 @@ export class WorkerDomAdapter extends DomAdapter {
     }
   }
 
-  hasProperty(element, name: string): boolean { throw "not implemented"; }
+  hasProperty(element: any /** TODO #9100 */, name: string): boolean { throw "not implemented"; }
   setProperty(el: Element, name: string, value: any) { throw "not implemented"; }
   getProperty(el: Element, name: string): any { throw "not implemented"; }
   invoke(el: Element, methodName: string, args: any[]): any { throw "not implemented"; }
@@ -46,94 +46,94 @@ export class WorkerDomAdapter extends DomAdapter {
 
   parse(templateHtml: string) { throw "not implemented"; }
   query(selector: string): any { throw "not implemented"; }
-  querySelector(el, selector: string): HTMLElement { throw "not implemented"; }
-  querySelectorAll(el, selector: string): any[] { throw "not implemented"; }
-  on(el, evt, listener) { throw "not implemented"; }
-  onAndCancel(el, evt, listener): Function { throw "not implemented"; }
-  dispatchEvent(el, evt) { throw "not implemented"; }
-  createMouseEvent(eventType): any { throw "not implemented"; }
+  querySelector(el: any /** TODO #9100 */, selector: string): HTMLElement { throw "not implemented"; }
+  querySelectorAll(el: any /** TODO #9100 */, selector: string): any[] { throw "not implemented"; }
+  on(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */) { throw "not implemented"; }
+  onAndCancel(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */): Function { throw "not implemented"; }
+  dispatchEvent(el: any /** TODO #9100 */, evt: any /** TODO #9100 */) { throw "not implemented"; }
+  createMouseEvent(eventType: any /** TODO #9100 */): any { throw "not implemented"; }
   createEvent(eventType: string): any { throw "not implemented"; }
-  preventDefault(evt) { throw "not implemented"; }
-  isPrevented(evt): boolean { throw "not implemented"; }
-  getInnerHTML(el): string { throw "not implemented"; }
-  getTemplateContent(el): any { throw "not implemented"; }
-  getOuterHTML(el): string { throw "not implemented"; }
-  nodeName(node): string { throw "not implemented"; }
-  nodeValue(node): string { throw "not implemented"; }
-  type(node): string { throw "not implemented"; }
-  content(node): any { throw "not implemented"; }
-  firstChild(el): Node { throw "not implemented"; }
-  nextSibling(el): Node { throw "not implemented"; }
-  parentElement(el): Node { throw "not implemented"; }
-  childNodes(el): Node[] { throw "not implemented"; }
-  childNodesAsList(el): Node[] { throw "not implemented"; }
-  clearNodes(el) { throw "not implemented"; }
-  appendChild(el, node) { throw "not implemented"; }
-  removeChild(el, node) { throw "not implemented"; }
-  replaceChild(el, newNode, oldNode) { throw "not implemented"; }
-  remove(el): Node { throw "not implemented"; }
-  insertBefore(el, node) { throw "not implemented"; }
-  insertAllBefore(el, nodes) { throw "not implemented"; }
-  insertAfter(el, node) { throw "not implemented"; }
-  setInnerHTML(el, value) { throw "not implemented"; }
-  getText(el): string { throw "not implemented"; }
-  setText(el, value: string) { throw "not implemented"; }
-  getValue(el): string { throw "not implemented"; }
-  setValue(el, value: string) { throw "not implemented"; }
-  getChecked(el): boolean { throw "not implemented"; }
-  setChecked(el, value: boolean) { throw "not implemented"; }
+  preventDefault(evt: any /** TODO #9100 */) { throw "not implemented"; }
+  isPrevented(evt: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  getInnerHTML(el: any /** TODO #9100 */): string { throw "not implemented"; }
+  getTemplateContent(el: any /** TODO #9100 */): any { throw "not implemented"; }
+  getOuterHTML(el: any /** TODO #9100 */): string { throw "not implemented"; }
+  nodeName(node: any /** TODO #9100 */): string { throw "not implemented"; }
+  nodeValue(node: any /** TODO #9100 */): string { throw "not implemented"; }
+  type(node: any /** TODO #9100 */): string { throw "not implemented"; }
+  content(node: any /** TODO #9100 */): any { throw "not implemented"; }
+  firstChild(el: any /** TODO #9100 */): Node { throw "not implemented"; }
+  nextSibling(el: any /** TODO #9100 */): Node { throw "not implemented"; }
+  parentElement(el: any /** TODO #9100 */): Node { throw "not implemented"; }
+  childNodes(el: any /** TODO #9100 */): Node[] { throw "not implemented"; }
+  childNodesAsList(el: any /** TODO #9100 */): Node[] { throw "not implemented"; }
+  clearNodes(el: any /** TODO #9100 */) { throw "not implemented"; }
+  appendChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { throw "not implemented"; }
+  removeChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { throw "not implemented"; }
+  replaceChild(el: any /** TODO #9100 */, newNode: any /** TODO #9100 */, oldNode: any /** TODO #9100 */) { throw "not implemented"; }
+  remove(el: any /** TODO #9100 */): Node { throw "not implemented"; }
+  insertBefore(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { throw "not implemented"; }
+  insertAllBefore(el: any /** TODO #9100 */, nodes: any /** TODO #9100 */) { throw "not implemented"; }
+  insertAfter(el: any /** TODO #9100 */, node: any /** TODO #9100 */) { throw "not implemented"; }
+  setInnerHTML(el: any /** TODO #9100 */, value: any /** TODO #9100 */) { throw "not implemented"; }
+  getText(el: any /** TODO #9100 */): string { throw "not implemented"; }
+  setText(el: any /** TODO #9100 */, value: string) { throw "not implemented"; }
+  getValue(el: any /** TODO #9100 */): string { throw "not implemented"; }
+  setValue(el: any /** TODO #9100 */, value: string) { throw "not implemented"; }
+  getChecked(el: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  setChecked(el: any /** TODO #9100 */, value: boolean) { throw "not implemented"; }
   createComment(text: string): any { throw "not implemented"; }
-  createTemplate(html): HTMLElement { throw "not implemented"; }
-  createElement(tagName, doc?): HTMLElement { throw "not implemented"; }
-  createElementNS(ns: string, tagName: string, doc?): Element { throw "not implemented"; }
-  createTextNode(text: string, doc?): Text { throw "not implemented"; }
-  createScriptTag(attrName: string, attrValue: string, doc?): HTMLElement {
+  createTemplate(html: any /** TODO #9100 */): HTMLElement { throw "not implemented"; }
+  createElement(tagName: any /** TODO #9100 */, doc?: any /** TODO #9100 */): HTMLElement { throw "not implemented"; }
+  createElementNS(ns: string, tagName: string, doc?: any /** TODO #9100 */): Element { throw "not implemented"; }
+  createTextNode(text: string, doc?: any /** TODO #9100 */): Text { throw "not implemented"; }
+  createScriptTag(attrName: string, attrValue: string, doc?: any /** TODO #9100 */): HTMLElement {
     throw "not implemented";
   }
-  createStyleElement(css: string, doc?): HTMLStyleElement { throw "not implemented"; }
-  createShadowRoot(el): any { throw "not implemented"; }
-  getShadowRoot(el): any { throw "not implemented"; }
-  getHost(el): any { throw "not implemented"; }
-  getDistributedNodes(el): Node[] { throw "not implemented"; }
+  createStyleElement(css: string, doc?: any /** TODO #9100 */): HTMLStyleElement { throw "not implemented"; }
+  createShadowRoot(el: any /** TODO #9100 */): any { throw "not implemented"; }
+  getShadowRoot(el: any /** TODO #9100 */): any { throw "not implemented"; }
+  getHost(el: any /** TODO #9100 */): any { throw "not implemented"; }
+  getDistributedNodes(el: any /** TODO #9100 */): Node[] { throw "not implemented"; }
   clone(node: Node): Node { throw "not implemented"; }
-  getElementsByClassName(element, name: string): HTMLElement[] { throw "not implemented"; }
-  getElementsByTagName(element, name: string): HTMLElement[] { throw "not implemented"; }
-  classList(element): any[] { throw "not implemented"; }
-  addClass(element, className: string) { throw "not implemented"; }
-  removeClass(element, className: string) { throw "not implemented"; }
-  hasClass(element, className: string): boolean { throw "not implemented"; }
-  setStyle(element, styleName: string, styleValue: string) { throw "not implemented"; }
-  removeStyle(element, styleName: string) { throw "not implemented"; }
-  getStyle(element, styleName: string): string { throw "not implemented"; }
-  hasStyle(element, styleName: string, styleValue?: string): boolean { throw "not implemented"; }
-  tagName(element): string { throw "not implemented"; }
-  attributeMap(element): Map<string, string> { throw "not implemented"; }
-  hasAttribute(element, attribute: string): boolean { throw "not implemented"; }
-  hasAttributeNS(element, ns: string, attribute: string): boolean { throw "not implemented"; }
-  getAttribute(element, attribute: string): string { throw "not implemented"; }
-  getAttributeNS(element, ns: string, attribute: string): string { throw "not implemented"; }
-  setAttribute(element, name: string, value: string) { throw "not implemented"; }
-  setAttributeNS(element, ns: string, name: string, value: string) { throw "not implemented"; }
-  removeAttribute(element, attribute: string) { throw "not implemented"; }
-  removeAttributeNS(element, ns: string, attribute: string) { throw "not implemented"; }
-  templateAwareRoot(el) { throw "not implemented"; }
+  getElementsByClassName(element: any /** TODO #9100 */, name: string): HTMLElement[] { throw "not implemented"; }
+  getElementsByTagName(element: any /** TODO #9100 */, name: string): HTMLElement[] { throw "not implemented"; }
+  classList(element: any /** TODO #9100 */): any[] { throw "not implemented"; }
+  addClass(element: any /** TODO #9100 */, className: string) { throw "not implemented"; }
+  removeClass(element: any /** TODO #9100 */, className: string) { throw "not implemented"; }
+  hasClass(element: any /** TODO #9100 */, className: string): boolean { throw "not implemented"; }
+  setStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string) { throw "not implemented"; }
+  removeStyle(element: any /** TODO #9100 */, styleName: string) { throw "not implemented"; }
+  getStyle(element: any /** TODO #9100 */, styleName: string): string { throw "not implemented"; }
+  hasStyle(element: any /** TODO #9100 */, styleName: string, styleValue?: string): boolean { throw "not implemented"; }
+  tagName(element: any /** TODO #9100 */): string { throw "not implemented"; }
+  attributeMap(element: any /** TODO #9100 */): Map<string, string> { throw "not implemented"; }
+  hasAttribute(element: any /** TODO #9100 */, attribute: string): boolean { throw "not implemented"; }
+  hasAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): boolean { throw "not implemented"; }
+  getAttribute(element: any /** TODO #9100 */, attribute: string): string { throw "not implemented"; }
+  getAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): string { throw "not implemented"; }
+  setAttribute(element: any /** TODO #9100 */, name: string, value: string) { throw "not implemented"; }
+  setAttributeNS(element: any /** TODO #9100 */, ns: string, name: string, value: string) { throw "not implemented"; }
+  removeAttribute(element: any /** TODO #9100 */, attribute: string) { throw "not implemented"; }
+  removeAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string) { throw "not implemented"; }
+  templateAwareRoot(el: any /** TODO #9100 */) { throw "not implemented"; }
   createHtmlDocument(): HTMLDocument { throw "not implemented"; }
   defaultDoc(): HTMLDocument { throw "not implemented"; }
-  getBoundingClientRect(el) { throw "not implemented"; }
+  getBoundingClientRect(el: any /** TODO #9100 */) { throw "not implemented"; }
   getTitle(): string { throw "not implemented"; }
   setTitle(newTitle: string) { throw "not implemented"; }
-  elementMatches(n, selector: string): boolean { throw "not implemented"; }
+  elementMatches(n: any /** TODO #9100 */, selector: string): boolean { throw "not implemented"; }
   isTemplateElement(el: any): boolean { throw "not implemented"; }
-  isTextNode(node): boolean { throw "not implemented"; }
-  isCommentNode(node): boolean { throw "not implemented"; }
-  isElementNode(node): boolean { throw "not implemented"; }
-  hasShadowRoot(node): boolean { throw "not implemented"; }
-  isShadowRoot(node): boolean { throw "not implemented"; }
+  isTextNode(node: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  isCommentNode(node: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  isElementNode(node: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  hasShadowRoot(node: any /** TODO #9100 */): boolean { throw "not implemented"; }
+  isShadowRoot(node: any /** TODO #9100 */): boolean { throw "not implemented"; }
   importIntoDoc(node: Node): Node { throw "not implemented"; }
   adoptNode(node: Node): Node { throw "not implemented"; }
-  getHref(element): string { throw "not implemented"; }
-  getEventKey(event): string { throw "not implemented"; }
-  resolveAndSetHref(element, baseUrl: string, href: string) { throw "not implemented"; }
+  getHref(element: any /** TODO #9100 */): string { throw "not implemented"; }
+  getEventKey(event: any /** TODO #9100 */): string { throw "not implemented"; }
+  resolveAndSetHref(element: any /** TODO #9100 */, baseUrl: string, href: string) { throw "not implemented"; }
   supportsDOMEvents(): boolean { throw "not implemented"; }
   supportsNativeShadowDOM(): boolean { throw "not implemented"; }
   getGlobalEventTarget(target: string): any { throw "not implemented"; }
@@ -142,12 +142,12 @@ export class WorkerDomAdapter extends DomAdapter {
   getBaseHref(): string { throw "not implemented"; }
   resetBaseElement(): void { throw "not implemented"; }
   getUserAgent(): string { throw "not implemented"; }
-  setData(element, name: string, value: string) { throw "not implemented"; }
-  getComputedStyle(element): any { throw "not implemented"; }
-  getData(element, name: string): string { throw "not implemented"; }
+  setData(element: any /** TODO #9100 */, name: string, value: string) { throw "not implemented"; }
+  getComputedStyle(element: any /** TODO #9100 */): any { throw "not implemented"; }
+  getData(element: any /** TODO #9100 */, name: string): string { throw "not implemented"; }
   setGlobalVar(name: string, value: any) { throw "not implemented"; }
-  requestAnimationFrame(callback): number { throw "not implemented"; }
-  cancelAnimationFrame(id) { throw "not implemented"; }
+  requestAnimationFrame(callback: any /** TODO #9100 */): number { throw "not implemented"; }
+  cancelAnimationFrame(id: any /** TODO #9100 */) { throw "not implemented"; }
   performanceNow(): number { throw "not implemented"; }
   getAnimationPrefix(): string { throw "not implemented"; }
   getTransitionEnd(): string { throw "not implemented"; }
diff --git a/modules/@angular/platform-browser/src/worker_render.ts b/modules/@angular/platform-browser/src/worker_render.ts
index 729f55716b..c553aa3cc3 100644
--- a/modules/@angular/platform-browser/src/worker_render.ts
+++ b/modules/@angular/platform-browser/src/worker_render.ts
@@ -113,7 +113,7 @@ export function initializeGenericWorkerRenderer(injector: Injector) {
 
   // initialize message services after the bus has been created
   let services = injector.get(WORKER_RENDER_STARTABLE_MESSAGING_SERVICE);
-  zone.runGuarded(() => { services.forEach((svc) => { svc.start(); }); });
+  zone.runGuarded(() => { services.forEach((svc: any /** TODO #9100 */) => { svc.start(); }); });
 }
 
 export function bootstrapRender(
diff --git a/modules/@angular/platform-browser/test/browser/bootstrap_spec.ts b/modules/@angular/platform-browser/test/browser/bootstrap_spec.ts
index bac96aa19b..d6a9657cc2 100644
--- a/modules/@angular/platform-browser/test/browser/bootstrap_spec.ts
+++ b/modules/@angular/platform-browser/test/browser/bootstrap_spec.ts
@@ -55,16 +55,16 @@ class HelloRootCmp2 {
 
 @Component({selector: 'hello-app', template: ''})
 class HelloRootCmp3 {
-  appBinding;
+  appBinding: any /** TODO #9100 */;
 
-  constructor(@Inject("appBinding") appBinding) { this.appBinding = appBinding; }
+  constructor(@Inject("appBinding") appBinding: any /** TODO #9100 */) { this.appBinding = appBinding; }
 }
 
 @Component({selector: 'hello-app', template: ''})
 class HelloRootCmp4 {
-  appRef;
+  appRef: any /** TODO #9100 */;
 
-  constructor(@Inject(ApplicationRef) appRef) { this.appRef = appRef; }
+  constructor(@Inject(ApplicationRef) appRef: any /** TODO #9100 */) { this.appRef = appRef; }
 }
 
 @Component({selector: 'hello-app'})
@@ -78,7 +78,7 @@ class HelloRootDirectiveIsNotCmp {
 @Component({selector: 'hello-app', template: ''})
 class HelloOnDestroyTickCmp implements OnDestroy {
   appRef: ApplicationRef;
-  constructor(@Inject(ApplicationRef) appRef) { this.appRef = appRef; }
+  constructor(@Inject(ApplicationRef) appRef: any /** TODO #9100 */) { this.appRef = appRef; }
 
   ngOnDestroy(): void { this.appRef.tick(); }
 }
@@ -93,12 +93,12 @@ class _ArrayLogger {
 
 
 class DummyConsole implements Console {
-  log(message) {}
-  warn(message) {}
+  log(message: any /** TODO #9100 */) {}
+  warn(message: any /** TODO #9100 */) {}
 }
 
 export function main() {
-  var fakeDoc, el, el2, testProviders, lightDom;
+  var fakeDoc: any /** TODO #9100 */, el: any /** TODO #9100 */, el2: any /** TODO #9100 */, testProviders: any /** TODO #9100 */, lightDom: any /** TODO #9100 */;
 
   describe('bootstrap factory method', () => {
     beforeEach(() => {
@@ -129,7 +129,7 @@ export function main() {
       expect(logger.res.join("")).toContain("Could not compile");
     });
 
-    it('should throw if no element is found', inject([AsyncTestCompleter], (async) => {
+    it('should throw if no element is found', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var logger = new _ArrayLogger();
          var exceptionHandler = new ExceptionHandler(logger, false);
 
@@ -144,7 +144,7 @@ export function main() {
 
     if (getDOM().supportsDOMEvents()) {
       it('should forward the error to promise when bootstrap fails',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            // Skip for dart since it causes a confusing error message in console when test passes.
            var logger = new _ArrayLogger();
            var exceptionHandler = new ExceptionHandler(logger, false);
@@ -159,7 +159,7 @@ export function main() {
          }));
 
       it('should invoke the default exception handler when bootstrap fails',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var logger = new _ArrayLogger();
            var exceptionHandler = new ExceptionHandler(logger, false);
 
@@ -179,7 +179,7 @@ export function main() {
       expect(refPromise).not.toBe(null);
     });
 
-    it('should display hello world', inject([AsyncTestCompleter], (async) => {
+    it('should display hello world', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var refPromise = bootstrap(HelloRootCmp, testProviders);
          refPromise.then((ref) => {
            expect(el).toHaveText('hello world!');
@@ -187,7 +187,7 @@ export function main() {
          });
        }));
 
-    it('should support multiple calls to bootstrap', inject([AsyncTestCompleter], (async) => {
+    it('should support multiple calls to bootstrap', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var refPromise1 = bootstrap(HelloRootCmp, testProviders);
          var refPromise2 = bootstrap(HelloRootCmp2, testProviders);
          PromiseWrapper.all([refPromise1, refPromise2])
@@ -199,7 +199,7 @@ export function main() {
        }));
 
     it('should not crash if change detection is invoked when the root component is disposed',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(HelloOnDestroyTickCmp, testProviders)
              .then((ref) => {
                expect(() => ref.destroy()).not.toThrow();
@@ -208,7 +208,7 @@ export function main() {
        }));
 
     it('should unregister change detectors when components are disposed',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var platform = createPlatform(ReflectiveInjector.resolveAndCreate(BROWSER_PLATFORM_PROVIDERS));
          var app =
              ReflectiveInjector.resolveAndCreate([BROWSER_APP_PROVIDERS, BROWSER_APP_COMPILER_PROVIDERS, testProviders],
@@ -223,7 +223,7 @@ export function main() {
        }));
 
     it("should make the provided bindings available to the application component",
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var refPromise = bootstrap(
              HelloRootCmp3, [testProviders, {provide: "appBinding", useValue: "BoundValue"}]);
 
@@ -234,7 +234,7 @@ export function main() {
        }));
 
     it("should avoid cyclic dependencies when root component requires Lifecycle through DI",
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var refPromise = bootstrap(HelloRootCmp4, testProviders);
 
          refPromise.then((ref) => {
@@ -264,7 +264,7 @@ export function main() {
        }));
 
     it('should register each application with the testability registry',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var refPromise1: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp, testProviders);
          var refPromise2: Promise<ComponentRef<any>> = bootstrap(HelloRootCmp2, testProviders);
 
diff --git a/modules/@angular/platform-browser/test/browser/rectangle_mock.ts b/modules/@angular/platform-browser/test/browser/rectangle_mock.ts
index c8a8a3140a..89043e69ea 100644
--- a/modules/@angular/platform-browser/test/browser/rectangle_mock.ts
+++ b/modules/@angular/platform-browser/test/browser/rectangle_mock.ts
@@ -1,3 +1,3 @@
-export function createRectangle(left, top, width, height) {
+export function createRectangle(left: any /** TODO #9100 */, top: any /** TODO #9100 */, width: any /** TODO #9100 */, height: any /** TODO #9100 */) {
   return {left, top, width, height};
 }
diff --git a/modules/@angular/platform-browser/test/browser/tools/spies.ts b/modules/@angular/platform-browser/test/browser/tools/spies.ts
index e7a5d0a4ba..b6d8e65c21 100644
--- a/modules/@angular/platform-browser/test/browser/tools/spies.ts
+++ b/modules/@angular/platform-browser/test/browser/tools/spies.ts
@@ -8,7 +8,7 @@ export class SpyApplicationRef extends SpyObject {
 }
 
 export class SpyComponentRef extends SpyObject {
-  injector;
+  injector: any /** TODO #9100 */;
   constructor() {
     super();
     this.injector = ReflectiveInjector.resolveAndCreate(
@@ -16,6 +16,6 @@ export class SpyComponentRef extends SpyObject {
   }
 }
 
-export function callNgProfilerTimeChangeDetection(config?): void {
+export function callNgProfilerTimeChangeDetection(config?: any /** TODO #9100 */): void {
   (<any>global).ng.profiler.timeChangeDetection(config);
 }
diff --git a/modules/@angular/platform-browser/test/dom/events/event_manager_spec.ts b/modules/@angular/platform-browser/test/dom/events/event_manager_spec.ts
index 4d2a19f9cf..80a0e1169e 100644
--- a/modules/@angular/platform-browser/test/dom/events/event_manager_spec.ts
+++ b/modules/@angular/platform-browser/test/dom/events/event_manager_spec.ts
@@ -19,7 +19,7 @@ import {
 import {el} from '../../../testing/browser_util';
 
 export function main() {
-  var domEventPlugin;
+  var domEventPlugin: any /** TODO #9100 */;
 
   describe('EventManager', () => {
 
@@ -28,7 +28,7 @@ export function main() {
     it('should delegate event bindings to plugins that are passed in from the most generic one to the most specific one',
        () => {
          var element = el('<div></div>');
-         var handler = (e) => e;
+         var handler = (e: any /** TODO #9100 */) => e;
          var plugin = new FakeEventManagerPlugin(['click']);
          var manager = new EventManager([domEventPlugin, plugin], new FakeNgZone());
          manager.addEventListener(element, 'click', handler);
@@ -37,8 +37,8 @@ export function main() {
 
     it('should delegate event bindings to the first plugin supporting the event', () => {
       var element = el('<div></div>');
-      var clickHandler = (e) => e;
-      var dblClickHandler = (e) => e;
+      var clickHandler = (e: any /** TODO #9100 */) => e;
+      var dblClickHandler = (e: any /** TODO #9100 */) => e;
       var plugin1 = new FakeEventManagerPlugin(['dblclick']);
       var plugin2 = new FakeEventManagerPlugin(['click', 'dblclick']);
       var manager = new EventManager([plugin2, plugin1], new FakeNgZone());
@@ -65,8 +65,8 @@ export function main() {
 
       var child = getDOM().firstChild(element);
       var dispatchedEvent = getDOM().createMouseEvent('click');
-      var receivedEvent = null;
-      var handler = (e) => { receivedEvent = e; };
+      var receivedEvent: any /** TODO #9100 */ = null;
+      var handler = (e: any /** TODO #9100 */) => { receivedEvent = e; };
       var manager = new EventManager([domEventPlugin], new FakeNgZone());
       manager.addEventListener(element, 'click', handler);
       getDOM().dispatchEvent(child, dispatchedEvent);
@@ -78,8 +78,8 @@ export function main() {
       var element = el('<div><div></div></div>');
       getDOM().appendChild(getDOM().defaultDoc().body, element);
       var dispatchedEvent = getDOM().createMouseEvent('click');
-      var receivedEvent = null;
-      var handler = (e) => { receivedEvent = e; };
+      var receivedEvent: any /** TODO #9100 */ = null;
+      var handler = (e: any /** TODO #9100 */) => { receivedEvent = e; };
       var manager = new EventManager([domEventPlugin], new FakeNgZone());
 
       var remover = manager.addGlobalEventListener("document", 'click', handler);
@@ -100,7 +100,7 @@ class FakeEventManagerPlugin extends EventManagerPlugin {
 
   supports(eventName: string): boolean { return ListWrapper.contains(this._supports, eventName); }
 
-  addEventListener(element, eventName: string, handler: Function) {
+  addEventListener(element: any /** TODO #9100 */, eventName: string, handler: Function) {
     this._eventHandler.set(eventName, handler);
     return () => { this._eventHandler.delete(eventName); };
   }
@@ -108,7 +108,7 @@ class FakeEventManagerPlugin extends EventManagerPlugin {
 
 class FakeNgZone extends NgZone {
   constructor() { super({enableLongStackTrace: false}); }
-  run(fn) { fn(); }
+  run(fn: any /** TODO #9100 */) { fn(); }
 
-  runOutsideAngular(fn) { return fn(); }
+  runOutsideAngular(fn: any /** TODO #9100 */) { return fn(); }
 }
diff --git a/modules/@angular/platform-browser/test/dom/shared_styles_host_spec.ts b/modules/@angular/platform-browser/test/dom/shared_styles_host_spec.ts
index 0709d96fb8..f1eb222454 100644
--- a/modules/@angular/platform-browser/test/dom/shared_styles_host_spec.ts
+++ b/modules/@angular/platform-browser/test/dom/shared_styles_host_spec.ts
@@ -15,7 +15,7 @@ import {DomSharedStylesHost} from '@angular/platform-browser/src/dom/shared_styl
 
 export function main() {
   describe('DomSharedStylesHost', () => {
-    var doc;
+    var doc: any /** TODO #9100 */;
     var ssh: DomSharedStylesHost;
     var someHost: Element;
     beforeEach(() => {
diff --git a/modules/@angular/platform-browser/test/dom/web_animations_player_spec.ts b/modules/@angular/platform-browser/test/dom/web_animations_player_spec.ts
index 3832a02735..1ed8ad5a0f 100644
--- a/modules/@angular/platform-browser/test/dom/web_animations_player_spec.ts
+++ b/modules/@angular/platform-browser/test/dom/web_animations_player_spec.ts
@@ -58,7 +58,7 @@ export function main() {
   }
 
   describe('WebAnimationsPlayer', () => {
-    var player, captures;
+    var player: any /** TODO #9100 */, captures: any /** TODO #9100 */;
     beforeEach(() => {
       var newPlayer = makePlayer();
       captures = <{[key: string]: any}>newPlayer['captures'];
diff --git a/modules/@angular/platform-browser/test/testing_public_browser_spec.ts b/modules/@angular/platform-browser/test/testing_public_browser_spec.ts
index ed89b7add9..e33bdcfeec 100644
--- a/modules/@angular/platform-browser/test/testing_public_browser_spec.ts
+++ b/modules/@angular/platform-browser/test/testing_public_browser_spec.ts
@@ -123,11 +123,11 @@ export function main() {
         beforeEachProviders(() => [{provide: FancyService, useValue: new FancyService()}]);
 
         it('provides a real XHR instance',
-           inject([XHR], (xhr) => { expect(xhr).toBeAnInstanceOf(XHRImpl); }));
+           inject([XHR], (xhr: any /** TODO #9100 */) => { expect(xhr).toBeAnInstanceOf(XHRImpl); }));
 
-        it('should allow the use of fakeAsync', fakeAsync(inject([FancyService], (service) => {
-             var value;
-             service.getAsyncValue().then(function(val) { value = val; });
+        it('should allow the use of fakeAsync', fakeAsync(inject([FancyService], (service: any /** TODO #9100 */) => {
+             var value: any /** TODO #9100 */;
+             service.getAsyncValue().then(function(val: any /** TODO #9100 */) { value = val; });
              tick();
              expect(value).toEqual('async value');
            })));
@@ -140,9 +140,9 @@ export function main() {
       var patchJasmineIt = () => {
         var deferred = PromiseWrapper.completer();
         originalJasmineIt = jasmine.getEnv().it;
-        jasmine.getEnv().it = (description: string, fn) => {
+        jasmine.getEnv().it = (description: string, fn: any /** TODO #9100 */) => {
           var done = () => { deferred.resolve() };
-          (<any>done).fail = (err) => { deferred.reject(err) };
+          (<any>done).fail = (err: any /** TODO #9100 */) => { deferred.reject(err) };
           fn(done);
           return null;
         };
@@ -151,12 +151,12 @@ export function main() {
 
       var restoreJasmineIt = () => { jasmine.getEnv().it = originalJasmineIt; };
 
-      it('should fail when an XHR fails', (done) => {
+      it('should fail when an XHR fails', (done: any /** TODO #9100 */) => {
         var itPromise = patchJasmineIt();
 
         it('should fail with an error from a promise',
            async(inject([TestComponentBuilder],
-                        (tcb) => { return tcb.createAsync(BadTemplateUrl); })));
+                        (tcb: any /** TODO #9100 */) => { return tcb.createAsync(BadTemplateUrl); })));
 
         itPromise.then(() => { done.fail('Expected test to fail, but it did not'); }, (err) => {
           expect(err).toEqual('Uncaught (in promise): Failed to load non-existant.html');
diff --git a/modules/@angular/platform-browser/test/testing_public_spec.ts b/modules/@angular/platform-browser/test/testing_public_spec.ts
index 5be7bbdc1f..4aeb474455 100644
--- a/modules/@angular/platform-browser/test/testing_public_spec.ts
+++ b/modules/@angular/platform-browser/test/testing_public_spec.ts
@@ -116,7 +116,7 @@ export function main() {
 
     it('should run normal tests', () => { actuallyDone = true; });
 
-    it('should run normal async tests', (done) => {
+    it('should run normal async tests', (done: any /** TODO #9100 */) => {
       setTimeout(() => {
         actuallyDone = true;
         done();
@@ -137,22 +137,22 @@ export function main() {
       beforeEachProviders(() => [{provide: FancyService, useValue: new FancyService()}]);
 
       it('should use set up providers',
-         inject([FancyService], (service) => { expect(service.value).toEqual('real value'); }));
+         inject([FancyService], (service: any /** TODO #9100 */) => { expect(service.value).toEqual('real value'); }));
 
-      it('should wait until returned promises', async(inject([FancyService], (service) => {
-           service.getAsyncValue().then((value) => { expect(value).toEqual('async value'); });
-           service.getTimeoutValue().then((value) => { expect(value).toEqual('timeout value'); });
+      it('should wait until returned promises', async(inject([FancyService], (service: any /** TODO #9100 */) => {
+           service.getAsyncValue().then((value: any /** TODO #9100 */) => { expect(value).toEqual('async value'); });
+           service.getTimeoutValue().then((value: any /** TODO #9100 */) => { expect(value).toEqual('timeout value'); });
          })));
 
-      it('should allow the use of fakeAsync', fakeAsync(inject([FancyService], (service) => {
-           var value;
-           service.getAsyncValue().then(function(val) { value = val; });
+      it('should allow the use of fakeAsync', fakeAsync(inject([FancyService], (service: any /** TODO #9100 */) => {
+           var value: any /** TODO #9100 */;
+           service.getAsyncValue().then(function(val: any /** TODO #9100 */) { value = val; });
            tick();
            expect(value).toEqual('async value');
          })));
 
-      it('should allow use of "done"', (done) => {
-        inject([FancyService], (service) => {
+      it('should allow use of "done"', (done: any /** TODO #9100 */) => {
+        inject([FancyService], (service: any /** TODO #9100 */) => {
           let count = 0;
           let id = setInterval(() => {
             count++;
@@ -166,20 +166,20 @@ export function main() {
 
       describe('using beforeEach', () => {
         beforeEach(inject([FancyService],
-                          (service) => { service.value = 'value modified in beforeEach'; }));
+                          (service: any /** TODO #9100 */) => { service.value = 'value modified in beforeEach'; }));
 
-        it('should use modified providers', inject([FancyService], (service) => {
+        it('should use modified providers', inject([FancyService], (service: any /** TODO #9100 */) => {
              expect(service.value).toEqual('value modified in beforeEach');
            }));
       });
 
       describe('using async beforeEach', () => {
-        beforeEach(async(inject([FancyService], (service) => {
-          service.getAsyncValue().then((value) => { service.value = value; });
+        beforeEach(async(inject([FancyService], (service: any /** TODO #9100 */) => {
+          service.getAsyncValue().then((value: any /** TODO #9100 */) => { service.value = value; });
         })));
 
         it('should use asynchronously modified value',
-           inject([FancyService], (service) => { expect(service.value).toEqual('async value'); }));
+           inject([FancyService], (service: any /** TODO #9100 */) => { expect(service.value).toEqual('async value'); }));
       });
     });
 
@@ -187,11 +187,11 @@ export function main() {
       it('should allow per test providers',
          withProviders(() => [{provide: FancyService, useValue: new FancyService()}])
              .inject([FancyService],
-                     (service) => { expect(service.value).toEqual('real value'); }));
+                     (service: any /** TODO #9100 */) => { expect(service.value).toEqual('real value'); }));
 
       it('should return value from inject', () => {
         let retval = withProviders(() => [{provide: FancyService, useValue: new FancyService()}])
-                         .inject([FancyService], (service) => {
+                         .inject([FancyService], (service: any /** TODO #9100 */) => {
                            expect(service.value).toEqual('real value');
                            return 10;
                          })();
@@ -207,9 +207,9 @@ export function main() {
     var patchJasmineIt = () => {
       var deferred = PromiseWrapper.completer();
       originalJasmineIt = jasmine.getEnv().it;
-      jasmine.getEnv().it = (description: string, fn) => {
+      jasmine.getEnv().it = (description: string, fn: any /** TODO #9100 */) => {
         var done = () => { deferred.resolve() };
-        (<any>done).fail = (err) => { deferred.reject(err) };
+        (<any>done).fail = (err: any /** TODO #9100 */) => { deferred.reject(err) };
         fn(done);
         return null;
       };
@@ -223,7 +223,7 @@ export function main() {
       originalJasmineBeforeEach = jasmine.getEnv().beforeEach;
       jasmine.getEnv().beforeEach = (fn: any) => {
         var done = () => { deferred.resolve() };
-        (<any>done).fail = (err) => { deferred.reject(err) };
+        (<any>done).fail = (err: any /** TODO #9100 */) => { deferred.reject(err) };
         fn(done);
         return null;
       };
@@ -233,7 +233,7 @@ export function main() {
     var restoreJasmineBeforeEach =
         () => { jasmine.getEnv().beforeEach = originalJasmineBeforeEach; };
 
-    it('should fail when an asynchronous error is thrown', (done) => {
+    it('should fail when an asynchronous error is thrown', (done: any /** TODO #9100 */) => {
       var itPromise = patchJasmineIt();
 
       it('throws an async error',
@@ -246,7 +246,7 @@ export function main() {
       restoreJasmineIt();
     });
 
-    it('should fail when a returned promise is rejected', (done) => {
+    it('should fail when a returned promise is rejected', (done: any /** TODO #9100 */) => {
       var itPromise = patchJasmineIt();
 
       it('should fail with an error from a promise', async(inject([], () => {
@@ -268,7 +268,7 @@ export function main() {
       beforeEachProviders(() => [{provide: FancyService, useValue: new FancyService()}]);
 
       beforeEach(
-          inject([FancyService], (service) => { expect(service.value).toEqual('real value'); }));
+          inject([FancyService], (service: any /** TODO #9100 */) => { expect(service.value).toEqual('real value'); }));
 
       describe('nested beforeEachProviders', () => {
 
diff --git a/modules/@angular/platform-browser/test/web_workers/shared/message_bus_spec.ts b/modules/@angular/platform-browser/test/web_workers/shared/message_bus_spec.ts
index 180a4959ab..1d1d54f85a 100644
--- a/modules/@angular/platform-browser/test/web_workers/shared/message_bus_spec.ts
+++ b/modules/@angular/platform-browser/test/web_workers/shared/message_bus_spec.ts
@@ -24,7 +24,7 @@ export function main() {
     beforeEach(() => { bus = createConnectedMessageBus(); });
 
     it("should pass messages in the same channel from sink to source",
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          const CHANNEL = "CHANNEL 1";
          const MESSAGE = "Test message";
          bus.initChannel(CHANNEL, false);
@@ -38,7 +38,7 @@ export function main() {
          ObservableWrapper.callEmit(toEmitter, MESSAGE);
        }));
 
-    it("should broadcast", inject([AsyncTestCompleter], (async) => {
+    it("should broadcast", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          const CHANNEL = "CHANNEL 1";
          const MESSAGE = "TESTING";
          const NUM_LISTENERS = 2;
@@ -62,7 +62,7 @@ export function main() {
          ObservableWrapper.callEmit(toEmitter, MESSAGE);
        }));
 
-    it("should keep channels independent", inject([AsyncTestCompleter], (async) => {
+    it("should keep channels independent", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          const CHANNEL_ONE = "CHANNEL 1";
          const CHANNEL_TWO = "CHANNEL 2";
          const MESSAGE_ONE = "This is a message on CHANNEL 1";
@@ -114,7 +114,7 @@ export function main() {
     it("should buffer messages and wait for the zone to exit before sending",
        withProviders(() => [{provide: NgZone, useClass: MockNgZone}])
            .inject([AsyncTestCompleter, NgZone],
-                   (async, zone: MockNgZone) => {
+                   (async: any /** TODO #9100 */, zone: MockNgZone) => {
                      bus = createConnectedMessageBus();
                      setup(true, zone);
 
@@ -137,7 +137,7 @@ export function main() {
        500);
 
     it("should send messages immediatly when run outside the zone",
-       inject([AsyncTestCompleter, NgZone], (async, zone: MockNgZone) => {
+       inject([AsyncTestCompleter, NgZone], (async: any /** TODO #9100 */, zone: MockNgZone) => {
          bus = createConnectedMessageBus();
          setup(false, zone);
 
diff --git a/modules/@angular/platform-browser/test/web_workers/shared/service_message_broker_spec.ts b/modules/@angular/platform-browser/test/web_workers/shared/service_message_broker_spec.ts
index c04b2df4c1..c068944b7c 100644
--- a/modules/@angular/platform-browser/test/web_workers/shared/service_message_broker_spec.ts
+++ b/modules/@angular/platform-browser/test/web_workers/shared/service_message_broker_spec.ts
@@ -30,7 +30,7 @@ export function main() {
   beforeEachProviders(() => [Serializer, {provide: ON_WEB_WORKER, useValue: true}, RenderStore]);
 
   describe("UIMessageBroker", () => {
-    var messageBuses;
+    var messageBuses: any /** TODO #9100 */;
 
     beforeEach(() => {
       messageBuses = createPairedMessageBuses();
@@ -38,7 +38,7 @@ export function main() {
       messageBuses.worker.initChannel(CHANNEL);
     });
     it("should call registered method with correct arguments",
-       inject([Serializer], (serializer) => {
+       inject([Serializer], (serializer: any /** TODO #9100 */) => {
          var broker = new ServiceMessageBroker_(messageBuses.ui, serializer, CHANNEL);
          broker.registerMethod(TEST_METHOD, [PRIMITIVE, PRIMITIVE], (arg1, arg2) => {
            expect(arg1).toEqual(PASSED_ARG_1);
@@ -51,7 +51,7 @@ export function main() {
     // TODO(pkozlowski): this fails only in Edge with
     //   "No provider for RenderStore! (Serializer -> RenderStore)"
     if (!browserDetection.isEdge) {
-      it("should return promises to the worker", inject([Serializer], (serializer) => {
+      it("should return promises to the worker", inject([Serializer], (serializer: any /** TODO #9100 */) => {
            var broker = new ServiceMessageBroker_(messageBuses.ui, serializer, CHANNEL);
            broker.registerMethod(TEST_METHOD, [PRIMITIVE], (arg1) => {
              expect(arg1).toEqual(PASSED_ARG_1);
diff --git a/modules/@angular/platform-browser/test/web_workers/shared/web_worker_test_util.ts b/modules/@angular/platform-browser/test/web_workers/shared/web_worker_test_util.ts
index d89d375878..ec7790e1b1 100644
--- a/modules/@angular/platform-browser/test/web_workers/shared/web_worker_test_util.ts
+++ b/modules/@angular/platform-browser/test/web_workers/shared/web_worker_test_util.ts
@@ -51,7 +51,7 @@ export function expectBrokerCall(broker: SpyMessageBroker, methodName: string, v
           expect(args.args.length).toEqual(vals.length);
           ListWrapper.forEachWithIndex(vals, (v, i) => {expect(v).toEqual(args.args[i].value)});
         }
-        var promise = null;
+        var promise: any /** TODO #9100 */ = null;
         if (isPresent(handler)) {
           let givenValues = args.args.map((arg) => {arg.value});
           if (givenValues.length > 0) {
diff --git a/modules/@angular/platform-browser/test/web_workers/worker/platform_location_spec.ts b/modules/@angular/platform-browser/test/web_workers/worker/platform_location_spec.ts
index c8f68cc2fc..44323c3d62 100644
--- a/modules/@angular/platform-browser/test/web_workers/worker/platform_location_spec.ts
+++ b/modules/@angular/platform-browser/test/web_workers/worker/platform_location_spec.ts
@@ -81,7 +81,7 @@ export function main() {
       expect(() => platformLocation.pathname = "TEST").toThrowError();
     });
 
-    it("should send pathname to render thread", inject([AsyncTestCompleter], (async) => {
+    it("should send pathname to render thread", inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          let platformLocation = createWebWorkerPlatformLocation(TEST_LOCATION);
          platformLocation.init().then((_) => {
            let PATHNAME = "/test";
diff --git a/modules/@angular/platform-browser/test/web_workers/worker/renderer_integration_spec.ts b/modules/@angular/platform-browser/test/web_workers/worker/renderer_integration_spec.ts
index f7e9bdb492..708dbc89af 100644
--- a/modules/@angular/platform-browser/test/web_workers/worker/renderer_integration_spec.ts
+++ b/modules/@angular/platform-browser/test/web_workers/worker/renderer_integration_spec.ts
@@ -100,7 +100,7 @@ export function main() {
         {provide: RenderStore, useValue: workerRenderStore},
         {
           provide: RootRenderer,
-          useFactory: (workerSerializer) => {
+          useFactory: (workerSerializer: any /** TODO #9100 */) => {
             return createWorkerRenderer(workerSerializer, uiSerializer, domRootRenderer,
                                         uiRenderStore, workerRenderStore);
           },
@@ -119,7 +119,7 @@ export function main() {
     }
 
     it('should update text nodes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MyComp2, new ViewMetadata({template: '<div>{{ctxProp}}</div>'}))
              .createAsync(MyComp2)
              .then((fixture) => {
@@ -135,12 +135,12 @@ export function main() {
        }));
 
     it('should update any element property/attributes/class/style(s) independent of the compilation on the root element and other elements',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MyComp2, new ViewMetadata(
                                        {template: '<input [title]="y" style="position:absolute">'}))
              .createAsync(MyComp2)
              .then((fixture) => {
-               var checkSetters = (componentRef, workerEl) => {
+               var checkSetters = (componentRef: any /** TODO #9100 */, workerEl: any /** TODO #9100 */) => {
                  var renderer = getRenderer(componentRef);
                  var el = getRenderElement(workerEl);
                  renderer.setElementProperty(workerEl, 'tabIndex', 1);
@@ -170,7 +170,7 @@ export function main() {
        }));
 
     it('should update any template comment property/attributes',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          var tpl = '<template [ngIf]="ctxBoolProp"></template>';
          tcb.overrideView(MyComp2, new ViewMetadata({template: tpl, directives: [NgIf]}))
 
@@ -185,7 +185,7 @@ export function main() {
        }));
 
     it('should add and remove fragments',
-       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+       inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
          tcb.overrideView(MyComp2, new ViewMetadata({
                             template: '<template [ngIf]="ctxBoolProp">hello</template>',
                             directives: [NgIf]
@@ -210,7 +210,7 @@ export function main() {
 
     if (getDOM().supportsDOMEvents()) {
       it('should call actions on the element',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp2, new ViewMetadata({template: '<input [title]="y">'}))
                .createAsync(MyComp2)
                .then((fixture) => {
@@ -225,7 +225,7 @@ export function main() {
          }));
 
       it('should listen to events',
-         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+         inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async: any /** TODO #9100 */) => {
            tcb.overrideView(MyComp2,
                             new ViewMetadata({template: '<input (change)="ctxNumProp = 1">'}))
                .createAsync(MyComp2)
@@ -248,7 +248,7 @@ export function main() {
 @Injectable()
 class MyComp2 {
   ctxProp: string;
-  ctxNumProp;
+  ctxNumProp: any /** TODO #9100 */;
   ctxBoolProp: boolean;
   constructor() {
     this.ctxProp = 'initial value';
diff --git a/modules/@angular/platform-browser/test/xhr/xhr_cache_setter.ts b/modules/@angular/platform-browser/test/xhr/xhr_cache_setter.ts
index e976333bd6..6af922bcac 100644
--- a/modules/@angular/platform-browser/test/xhr/xhr_cache_setter.ts
+++ b/modules/@angular/platform-browser/test/xhr/xhr_cache_setter.ts
@@ -1,3 +1,3 @@
-export function setTemplateCache(cache): void {
+export function setTemplateCache(cache: any /** TODO #9100 */): void {
   (<any>window).$templateCache = cache;
 }
diff --git a/modules/@angular/platform-browser/test/xhr/xhr_cache_spec.ts b/modules/@angular/platform-browser/test/xhr/xhr_cache_spec.ts
index 3f62b04aef..cbc3634c4d 100644
--- a/modules/@angular/platform-browser/test/xhr/xhr_cache_spec.ts
+++ b/modules/@angular/platform-browser/test/xhr/xhr_cache_spec.ts
@@ -43,7 +43,7 @@ export function main() {
     });
 
     it('should resolve the Promise with the cached file content on success',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          setTemplateCache({'test.html': '<div>Hello</div>'});
          xhr = new CachedXHR();
          xhr.get('test.html')
@@ -53,7 +53,7 @@ export function main() {
              });
        }));
 
-    it('should reject the Promise on failure', inject([AsyncTestCompleter], (async) => {
+    it('should reject the Promise on failure', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          xhr = new CachedXHR();
          xhr.get('unknown.html')
              .then((text) => { throw new BaseException('Not expected to succeed.'); })
diff --git a/modules/@angular/platform-browser/test/xhr/xhr_impl_spec.ts b/modules/@angular/platform-browser/test/xhr/xhr_impl_spec.ts
index 0a2d815142..8b1290ec7e 100644
--- a/modules/@angular/platform-browser/test/xhr/xhr_impl_spec.ts
+++ b/modules/@angular/platform-browser/test/xhr/xhr_impl_spec.ts
@@ -28,14 +28,14 @@ export function main() {
     beforeEach(() => { xhr = new XHRImpl(); });
 
     it('should resolve the Promise with the file content on success',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          xhr.get(url200).then((text) => {
            expect(text.trim()).toEqual('<p>hey</p>');
            async.done();
          });
        }), 10000);
 
-    it('should reject the Promise on failure', inject([AsyncTestCompleter], (async) => {
+    it('should reject the Promise on failure', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          PromiseWrapper.catchError(xhr.get(url404), (e) => {
            expect(e).toEqual(`Failed to load ${url404}`);
            async.done();
diff --git a/modules/@angular/platform-browser/testing/benchmark_util.ts b/modules/@angular/platform-browser/testing/benchmark_util.ts
index a23b5c5dca..c2acdbe43e 100644
--- a/modules/@angular/platform-browser/testing/benchmark_util.ts
+++ b/modules/@angular/platform-browser/testing/benchmark_util.ts
@@ -11,8 +11,8 @@ export function getIntParameter(name: string) {
 
 export function getStringParameter(name: string) {
   var els = DOM.querySelectorAll(document, `input[name="${name}"]`);
-  var value;
-  var el;
+  var value: any /** TODO #9100 */;
+  var el: any /** TODO #9100 */;
 
   for (var i = 0; i < els.length; i++) {
     el = els[i];
@@ -32,10 +32,10 @@ export function getStringParameter(name: string) {
 
 export function bindAction(selector: string, callback: Function) {
   var el = DOM.querySelector(document, selector);
-  DOM.on(el, 'click', function(_) { callback(); });
+  DOM.on(el, 'click', function(_: any /** TODO #9100 */) { callback(); });
 }
 
-export function microBenchmark(name, iterationCount, callback) {
+export function microBenchmark(name: any /** TODO #9100 */, iterationCount: any /** TODO #9100 */, callback: any /** TODO #9100 */) {
   var durationName = `${name}/${iterationCount}`;
   window.console.time(durationName);
   callback();
diff --git a/modules/@angular/platform-browser/testing/browser_util.ts b/modules/@angular/platform-browser/testing/browser_util.ts
index 7ae3beebcd..e1b03248c2 100644
--- a/modules/@angular/platform-browser/testing/browser_util.ts
+++ b/modules/@angular/platform-browser/testing/browser_util.ts
@@ -52,7 +52,7 @@ export class BrowserDetection {
 
 BrowserDetection.setup();
 
-export function dispatchEvent(element, eventType): void {
+export function dispatchEvent(element: any /** TODO #9100 */, eventType: any /** TODO #9100 */): void {
   getDOM().dispatchEvent(element, getDOM().createEvent(eventType));
 }
 
@@ -66,14 +66,14 @@ export function normalizeCSS(css: string): string {
   css = StringWrapper.replaceAll(css, /'/g, '"');
   css = StringWrapper.replaceAll(css, / }/g, '}');
   css = StringWrapper.replaceAllMapped(css, /url\((\"|\s)(.+)(\"|\s)\)(\s*)/g,
-                                       (match) => `url("${match[2]}")`);
+                                       (match: any /** TODO #9100 */) => `url("${match[2]}")`);
   css = StringWrapper.replaceAllMapped(css, /\[(.+)=([^"\]]+)\]/g,
-                                       (match) => `[${match[1]}="${match[2]}"]`);
+                                       (match: any /** TODO #9100 */) => `[${match[1]}="${match[2]}"]`);
   return css;
 }
 
 var _singleTagWhitelist = ['br', 'hr', 'input'];
-export function stringifyElement(el): string {
+export function stringifyElement(el: any /** TODO #9100 */): string {
   var result = '';
   if (getDOM().isElementNode(el)) {
     var tagName = getDOM().tagName(el).toLowerCase();
@@ -83,7 +83,7 @@ export function stringifyElement(el): string {
 
     // Attributes in an ordered way
     var attributeMap = getDOM().attributeMap(el);
-    var keys = [];
+    var keys: any[] /** TODO #9100 */ = [];
     attributeMap.forEach((v, k) => keys.push(k));
     ListWrapper.sort(keys);
     for (let i = 0; i < keys.length; i++) {
diff --git a/modules/@angular/platform-browser/testing/dom_test_component_renderer.ts b/modules/@angular/platform-browser/testing/dom_test_component_renderer.ts
index 977b04bb2a..7a2d2d7ae5 100644
--- a/modules/@angular/platform-browser/testing/dom_test_component_renderer.ts
+++ b/modules/@angular/platform-browser/testing/dom_test_component_renderer.ts
@@ -9,7 +9,7 @@ import {el} from './browser_util';
  */
 @Injectable()
 export class DOMTestComponentRenderer extends TestComponentRenderer {
-  constructor(@Inject(DOCUMENT) private _doc) { super(); }
+  constructor(@Inject(DOCUMENT) private _doc: any /** TODO #9100 */) { super(); }
 
   insertRootElement(rootElId: string) {
     let rootEl = el(`<div id="${rootElId}"></div>`);
diff --git a/modules/@angular/platform-browser/testing/e2e_util.ts b/modules/@angular/platform-browser/testing/e2e_util.ts
index 167cb2c412..6511b1d553 100644
--- a/modules/@angular/platform-browser/testing/e2e_util.ts
+++ b/modules/@angular/platform-browser/testing/e2e_util.ts
@@ -1,12 +1,12 @@
 import * as webdriver from 'selenium-webdriver';
 
-declare var global;
+declare var global: any /** TODO #9100 */;
 declare var expect: Function;
 export var browser: protractor.IBrowser = global['browser'];
 export var $: cssSelectorHelper = global['$'];
 
-export function clickAll(buttonSelectors) {
-  buttonSelectors.forEach(function(selector) { $(selector).click(); });
+export function clickAll(buttonSelectors: any /** TODO #9100 */) {
+  buttonSelectors.forEach(function(selector: any /** TODO #9100 */) { $(selector).click(); });
 }
 
 export function verifyNoBrowserErrors() {
diff --git a/modules/@angular/platform-browser/testing/matchers.ts b/modules/@angular/platform-browser/testing/matchers.ts
index 4574753952..0e9bc702f8 100644
--- a/modules/@angular/platform-browser/testing/matchers.ts
+++ b/modules/@angular/platform-browser/testing/matchers.ts
@@ -109,13 +109,13 @@ export var expect: (actual: any) => NgMatchers = <any>_global.expect;
 // gives us bad error messages in tests.
 // The only way to do this in Jasmine is to monkey patch a method
 // to the object :-(
-Map.prototype['jasmineToString'] = function() {
+(Map as any /** TODO #???? */).prototype['jasmineToString'] = function() {
   var m = this;
   if (!m) {
     return '' + m;
   }
-  var res = [];
-  m.forEach((v, k) => { res.push(`${k}:${v}`); });
+  var res: any[] /** TODO #???? */ = [];
+  m.forEach((v: any /** TODO #???? */, k: any /** TODO #???? */) => { res.push(`${k}:${v}`); });
   return `{ ${res.join(',')} }`;
 };
 
@@ -124,16 +124,16 @@ _global.beforeEach(function() {
     // Custom handler for Map as Jasmine does not support it yet
     toEqual: function(util, customEqualityTesters) {
       return {
-        compare: function(actual, expected) {
+        compare: function(actual: any /** TODO #???? */, expected: any /** TODO #???? */) {
           return {pass: util.equals(actual, expected, [compareMap])};
         }
       };
 
-      function compareMap(actual, expected) {
+      function compareMap(actual: any /** TODO #???? */, expected: any /** TODO #???? */) {
         if (actual instanceof Map) {
           var pass = actual.size === expected.size;
           if (pass) {
-            actual.forEach((v, k) => { pass = pass && util.equals(v, expected.get(k)); });
+            actual.forEach((v: any /** TODO #???? */, k: any /** TODO #???? */) => { pass = pass && util.equals(v, expected.get(k)); });
           }
           return pass;
         } else {
@@ -144,7 +144,7 @@ _global.beforeEach(function() {
 
     toBePromise: function() {
       return {
-        compare: function(actual, expectedClass) {
+        compare: function(actual: any /** TODO #???? */, expectedClass: any /** TODO #???? */) {
           var pass = typeof actual === 'object' && typeof actual.then === 'function';
           return {pass: pass, get message() { return 'Expected ' + actual + ' to be a promise'; }};
         }
@@ -153,7 +153,7 @@ _global.beforeEach(function() {
 
     toBeAnInstanceOf: function() {
       return {
-        compare: function(actual, expectedClass) {
+        compare: function(actual: any /** TODO #???? */, expectedClass: any /** TODO #???? */) {
           var pass = typeof actual === 'object' && actual instanceof expectedClass;
           return {
             pass: pass,
@@ -167,7 +167,7 @@ _global.beforeEach(function() {
 
     toHaveText: function() {
       return {
-        compare: function(actual, expectedText) {
+        compare: function(actual: any /** TODO #???? */, expectedText: any /** TODO #???? */) {
           var actualText = elementText(actual);
           return {
             pass: actualText == expectedText,
@@ -180,8 +180,8 @@ _global.beforeEach(function() {
     toHaveCssClass: function() {
       return {compare: buildError(false), negativeCompare: buildError(true)};
 
-      function buildError(isNot) {
-        return function(actual, className) {
+      function buildError(isNot: any /** TODO #???? */) {
+        return function(actual: any /** TODO #???? */, className: any /** TODO #???? */) {
           return {
             pass: getDOM().hasClass(actual, className) == !isNot,
             get message() {
@@ -194,13 +194,13 @@ _global.beforeEach(function() {
 
     toHaveCssStyle: function() {
       return {
-        compare: function(actual, styles) {
-          var allPassed;
+        compare: function(actual: any /** TODO #???? */, styles: any /** TODO #???? */) {
+          var allPassed: any /** TODO #???? */;
           if (isString(styles)) {
             allPassed = getDOM().hasStyle(actual, styles);
           } else {
             allPassed = !StringMapWrapper.isEmpty(styles);
-            StringMapWrapper.forEach(styles, (style, prop) => {
+            StringMapWrapper.forEach(styles, (style: any /** TODO #???? */, prop: any /** TODO #???? */) => {
               allPassed = allPassed && getDOM().hasStyle(actual, prop, style);
             });
           }
@@ -219,7 +219,7 @@ _global.beforeEach(function() {
 
     toContainError: function() {
       return {
-        compare: function(actual, expectedText) {
+        compare: function(actual: any /** TODO #???? */, expectedText: any /** TODO #???? */) {
           var errorMessage = actual.toString();
           return {
             pass: errorMessage.indexOf(expectedText) > -1,
@@ -231,7 +231,7 @@ _global.beforeEach(function() {
 
     toThrowErrorWith: function() {
       return {
-        compare: function(actual, expectedText) {
+        compare: function(actual: any /** TODO #???? */, expectedText: any /** TODO #???? */) {
           try {
             actual();
             return {
@@ -252,8 +252,8 @@ _global.beforeEach(function() {
     toMatchPattern() {
       return {compare: buildError(false), negativeCompare: buildError(true)};
 
-      function buildError(isNot) {
-        return function(actual, regex) {
+      function buildError(isNot: any /** TODO #???? */) {
+        return function(actual: any /** TODO #???? */, regex: any /** TODO #???? */) {
           return {
             pass: regex.test(actual) == !isNot,
             get message() {
@@ -266,11 +266,11 @@ _global.beforeEach(function() {
 
     toImplement: function() {
       return {
-        compare: function(actualObject, expectedInterface) {
+        compare: function(actualObject: any /** TODO #???? */, expectedInterface: any /** TODO #???? */) {
           var objProps = Object.keys(actualObject.constructor.prototype);
           var intProps = Object.keys(expectedInterface.prototype);
 
-          var missedMethods = [];
+          var missedMethods: any[] /** TODO #???? */ = [];
           intProps.forEach((k) => {
             if (!actualObject.constructor.prototype[k]) missedMethods.push(k);
           });
@@ -288,8 +288,8 @@ _global.beforeEach(function() {
   });
 });
 
-function elementText(n) {
-  var hasNodes = (n) => {
+function elementText(n: any /** TODO #???? */): any /** TODO #???? */ {
+  var hasNodes = (n: any /** TODO #???? */) => {
     var children = getDOM().childNodes(n);
     return children && children.length > 0;
   };
diff --git a/modules/@angular/platform-browser/testing/perf_util.ts b/modules/@angular/platform-browser/testing/perf_util.ts
index 0ccf45ce64..80533600fc 100644
--- a/modules/@angular/platform-browser/testing/perf_util.ts
+++ b/modules/@angular/platform-browser/testing/perf_util.ts
@@ -1,32 +1,32 @@
 export {verifyNoBrowserErrors} from './e2e_util';
 
-var benchpress = global['benchpress'];
+var benchpress = (global as any /** TODO #9100 */)['benchpress'];
 var bind = benchpress.bind;
 var Options = benchpress.Options;
 
-export function runClickBenchmark(config) {
+export function runClickBenchmark(config: any /** TODO #9100 */) {
   browser.ignoreSynchronization = !config.waitForAngular2;
-  var buttons = config.buttons.map(function(selector) { return $(selector); });
-  config.work = function() { buttons.forEach(function(button) { button.click(); }); };
+  var buttons = config.buttons.map(function(selector: any /** TODO #9100 */) { return $(selector); });
+  config.work = function() { buttons.forEach(function(button: any /** TODO #9100 */) { button.click(); }); };
   return runBenchmark(config);
 }
 
-export function runBenchmark(config) {
+export function runBenchmark(config: any /** TODO #9100 */) {
   return getScaleFactor(browser.params.benchmark.scaling)
       .then(function(scaleFactor) {
         var description = {};
-        var urlParams = [];
+        var urlParams: any[] /** TODO #9100 */ = [];
         if (config.params) {
-          config.params.forEach(function(param) {
+          config.params.forEach(function(param: any /** TODO #9100 */) {
             var name = param.name;
             var value = applyScaleFactor(param.value, scaleFactor, param.scale);
             urlParams.push(name + '=' + value);
-            description[name] = value;
+            (description as any /** TODO #9100 */)[name] = value;
           });
         }
         var url = encodeURI(config.url + '?' + urlParams.join('&'));
         return browser.get(url).then(function() {
-          return global['benchpressRunner'].sample({
+          return (global as any /** TODO #9100 */)['benchpressRunner'].sample({
             id: config.id,
             execute: config.work,
             prepare: config.prepare,
@@ -37,11 +37,11 @@ export function runBenchmark(config) {
       });
 }
 
-function getScaleFactor(possibleScalings) {
+function getScaleFactor(possibleScalings: any /** TODO #9100 */) {
   return browser.executeScript('return navigator.userAgent')
       .then(function(userAgent: string) {
         var scaleFactor = 1;
-        possibleScalings.forEach(function(entry) {
+        possibleScalings.forEach(function(entry: any /** TODO #9100 */) {
           if (userAgent.match(entry.userAgent)) {
             scaleFactor = entry.value;
           }
@@ -50,7 +50,7 @@ function getScaleFactor(possibleScalings) {
       });
 }
 
-function applyScaleFactor(value, scaleFactor, method) {
+function applyScaleFactor(value: any /** TODO #9100 */, scaleFactor: any /** TODO #9100 */, method: any /** TODO #9100 */) {
   if (method === 'log2') {
     return value + Math.log(scaleFactor) / Math.LN2;
   } else if (method === 'sqrt') {
diff --git a/modules/@angular/platform-server/src/parse5_adapter.ts b/modules/@angular/platform-server/src/parse5_adapter.ts
index b72cc0fb81..f16c254c11 100644
--- a/modules/@angular/platform-server/src/parse5_adapter.ts
+++ b/modules/@angular/platform-server/src/parse5_adapter.ts
@@ -7,9 +7,9 @@ import {BaseException} from '../src/facade/exceptions';
 import {SelectorMatcher, CssSelector} from '../compiler_private';
 import {XHR} from '@angular/compiler';
 
-var parser = null;
-var serializer = null;
-var treeAdapter = null;
+var parser: any /** TODO #9100 */ = null;
+var serializer: any /** TODO #9100 */ = null;
+var treeAdapter: any /** TODO #9100 */ = null;
 
 var _attrToPropMap: {[key: string]: string} = {
   'class': 'className',
@@ -17,11 +17,11 @@ var _attrToPropMap: {[key: string]: string} = {
   'readonly': 'readOnly',
   'tabindex': 'tabIndex',
 };
-var defDoc = null;
+var defDoc: any /** TODO #9100 */ = null;
 
 var mapProps = ['attribs', 'x-attribsNamespace', 'x-attribsPrefix'];
 
-function _notImplemented(methodName) {
+function _notImplemented(methodName: any /** TODO #9100 */) {
   return new BaseException('This method is not implemented in Parse5DomAdapter: ' + methodName);
 }
 
@@ -34,7 +34,7 @@ export class Parse5DomAdapter extends DomAdapter {
     setRootDomAdapter(new Parse5DomAdapter());
   }
 
-  hasProperty(element, name: string): boolean {
+  hasProperty(element: any /** TODO #9100 */, name: string): boolean {
     return _HTMLElementPropertyList.indexOf(name) > -1;
   }
   // TODO(tbosch): don't even call this method when we run the tests on server side
@@ -52,11 +52,11 @@ export class Parse5DomAdapter extends DomAdapter {
   // by not using the DomRenderer in tests. Keeping this for now to make tests happy...
   getProperty(el: /*element*/ any, name: string): any { return el[name]; }
 
-  logError(error) { console.error(error); }
+  logError(error: any /** TODO #9100 */) { console.error(error); }
 
-  log(error) { console.log(error); }
+  log(error: any /** TODO #9100 */) { console.log(error); }
 
-  logGroup(error) { console.error(error); }
+  logGroup(error: any /** TODO #9100 */) { console.error(error); }
 
   logGroupEnd() {}
 
@@ -64,11 +64,11 @@ export class Parse5DomAdapter extends DomAdapter {
 
   get attrToPropMap() { return _attrToPropMap; }
 
-  query(selector) { throw _notImplemented('query'); }
-  querySelector(el, selector: string): any { return this.querySelectorAll(el, selector)[0]; }
-  querySelectorAll(el, selector: string): any[] {
-    var res = [];
-    var _recursive = (result, node, selector, matcher) => {
+  query(selector: any /** TODO #9100 */) { throw _notImplemented('query'); }
+  querySelector(el: any /** TODO #9100 */, selector: string): any { return this.querySelectorAll(el, selector)[0]; }
+  querySelectorAll(el: any /** TODO #9100 */, selector: string): any[] {
+    var res: any[] /** TODO #9100 */ = [];
+    var _recursive = (result: any /** TODO #9100 */, node: any /** TODO #9100 */, selector: any /** TODO #9100 */, matcher: any /** TODO #9100 */) => {
       var cNodes = node.childNodes;
       if (cNodes && cNodes.length > 0) {
         for (var i = 0; i < cNodes.length; i++) {
@@ -85,7 +85,7 @@ export class Parse5DomAdapter extends DomAdapter {
     _recursive(res, el, selector, matcher);
     return res;
   }
-  elementMatches(node, selector: string, matcher = null): boolean {
+  elementMatches(node: any /** TODO #9100 */, selector: string, matcher: any /** TODO #9100 */ = null): boolean {
     if (this.isElementNode(node) && selector === '*') {
       return true;
     }
@@ -111,11 +111,11 @@ export class Parse5DomAdapter extends DomAdapter {
         cssSelector.addClassName(classList[i]);
       }
 
-      matcher.match(cssSelector, function(selector, cb) { result = true; });
+      matcher.match(cssSelector, function(selector: any /** TODO #9100 */, cb: any /** TODO #9100 */) { result = true; });
     }
     return result;
   }
-  on(el, evt, listener) {
+  on(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */) {
     var listenersMap: {[k: /*any*/ string]: any} = el._eventListenersMap;
     if (isBlank(listenersMap)) {
       var listenersMap: {[k: /*any*/ string]: any} = StringMapWrapper.create();
@@ -128,13 +128,13 @@ export class Parse5DomAdapter extends DomAdapter {
     listeners.push(listener);
     StringMapWrapper.set(listenersMap, evt, listeners);
   }
-  onAndCancel(el, evt, listener): Function {
+  onAndCancel(el: any /** TODO #9100 */, evt: any /** TODO #9100 */, listener: any /** TODO #9100 */): Function {
     this.on(el, evt, listener);
     return () => {
       ListWrapper.remove(StringMapWrapper.get<any[]>(el._eventListenersMap, evt), listener);
     };
   }
-  dispatchEvent(el, evt) {
+  dispatchEvent(el: any /** TODO #9100 */, evt: any /** TODO #9100 */) {
     if (isBlank(evt.target)) {
       evt.target = el;
     }
@@ -153,7 +153,7 @@ export class Parse5DomAdapter extends DomAdapter {
       this.dispatchEvent(el._window, evt);
     }
   }
-  createMouseEvent(eventType): Event { return this.createEvent(eventType); }
+  createMouseEvent(eventType: any /** TODO #9100 */): Event { return this.createEvent(eventType); }
   createEvent(eventType: string): Event {
     var evt = <Event>{
       type: eventType,
@@ -162,26 +162,26 @@ export class Parse5DomAdapter extends DomAdapter {
     };
     return evt;
   }
-  preventDefault(evt) { evt.returnValue = false; }
-  isPrevented(evt): boolean { return isPresent(evt.returnValue) && !evt.returnValue; }
-  getInnerHTML(el): string { return serializer.serialize(this.templateAwareRoot(el)); }
-  getTemplateContent(el): Node {
+  preventDefault(evt: any /** TODO #9100 */) { evt.returnValue = false; }
+  isPrevented(evt: any /** TODO #9100 */): boolean { return isPresent(evt.returnValue) && !evt.returnValue; }
+  getInnerHTML(el: any /** TODO #9100 */): string { return serializer.serialize(this.templateAwareRoot(el)); }
+  getTemplateContent(el: any /** TODO #9100 */): Node {
     return null;  // no <template> support in parse5.
   }
-  getOuterHTML(el): string {
+  getOuterHTML(el: any /** TODO #9100 */): string {
     serializer.html = '';
     serializer._serializeElement(el);
     return serializer.html;
   }
-  nodeName(node): string { return node.tagName; }
-  nodeValue(node): string { return node.nodeValue; }
+  nodeName(node: any /** TODO #9100 */): string { return node.tagName; }
+  nodeValue(node: any /** TODO #9100 */): string { return node.nodeValue; }
   type(node: any): string { throw _notImplemented('type'); }
-  content(node): string { return node.childNodes[0]; }
-  firstChild(el): Node { return el.firstChild; }
-  nextSibling(el): Node { return el.nextSibling; }
-  parentElement(el): Node { return el.parent; }
-  childNodes(el): Node[] { return el.childNodes; }
-  childNodesAsList(el): any[] {
+  content(node: any /** TODO #9100 */): string { return node.childNodes[0]; }
+  firstChild(el: any /** TODO #9100 */): Node { return el.firstChild; }
+  nextSibling(el: any /** TODO #9100 */): Node { return el.nextSibling; }
+  parentElement(el: any /** TODO #9100 */): Node { return el.parent; }
+  childNodes(el: any /** TODO #9100 */): Node[] { return el.childNodes; }
+  childNodesAsList(el: any /** TODO #9100 */): any[] {
     var childNodes = el.childNodes;
     var res = ListWrapper.createFixedSize(childNodes.length);
     for (var i = 0; i < childNodes.length; i++) {
@@ -189,21 +189,21 @@ export class Parse5DomAdapter extends DomAdapter {
     }
     return res;
   }
-  clearNodes(el) {
+  clearNodes(el: any /** TODO #9100 */) {
     while (el.childNodes.length > 0) {
       this.remove(el.childNodes[0]);
     }
   }
-  appendChild(el, node) {
+  appendChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) {
     this.remove(node);
     treeAdapter.appendChild(this.templateAwareRoot(el), node);
   }
-  removeChild(el, node) {
+  removeChild(el: any /** TODO #9100 */, node: any /** TODO #9100 */) {
     if (ListWrapper.contains(el.childNodes, node)) {
       this.remove(node);
     }
   }
-  remove(el): HTMLElement {
+  remove(el: any /** TODO #9100 */): HTMLElement {
     var parent = el.parent;
     if (parent) {
       var index = parent.childNodes.indexOf(el);
@@ -222,26 +222,26 @@ export class Parse5DomAdapter extends DomAdapter {
     el.parent = null;
     return el;
   }
-  insertBefore(el, node) {
+  insertBefore(el: any /** TODO #9100 */, node: any /** TODO #9100 */) {
     this.remove(node);
     treeAdapter.insertBefore(el.parent, node, el);
   }
-  insertAllBefore(el, nodes) { nodes.forEach(n => this.insertBefore(el, n)); }
-  insertAfter(el, node) {
+  insertAllBefore(el: any /** TODO #9100 */, nodes: any /** TODO #9100 */) { nodes.forEach((n: any /** TODO #9100 */) => this.insertBefore(el, n)); }
+  insertAfter(el: any /** TODO #9100 */, node: any /** TODO #9100 */) {
     if (el.nextSibling) {
       this.insertBefore(el.nextSibling, node);
     } else {
       this.appendChild(el.parent, node);
     }
   }
-  setInnerHTML(el, value) {
+  setInnerHTML(el: any /** TODO #9100 */, value: any /** TODO #9100 */) {
     this.clearNodes(el);
     var content = parser.parseFragment(value);
     for (var i = 0; i < content.childNodes.length; i++) {
       treeAdapter.appendChild(el, content.childNodes[i]);
     }
   }
-  getText(el, isRecursive?: boolean): string {
+  getText(el: any /** TODO #9100 */, isRecursive?: boolean): string {
     if (this.isTextNode(el)) {
       return el.data;
     } else if (this.isCommentNode(el)) {
@@ -258,7 +258,7 @@ export class Parse5DomAdapter extends DomAdapter {
       return textContent;
     }
   }
-  setText(el, value: string) {
+  setText(el: any /** TODO #9100 */, value: string) {
     if (this.isTextNode(el) || this.isCommentNode(el)) {
       el.data = value;
     } else {
@@ -266,21 +266,21 @@ export class Parse5DomAdapter extends DomAdapter {
       if (value !== '') treeAdapter.insertText(el, value);
     }
   }
-  getValue(el): string { return el.value; }
-  setValue(el, value: string) { el.value = value; }
-  getChecked(el): boolean { return el.checked; }
-  setChecked(el, value: boolean) { el.checked = value; }
+  getValue(el: any /** TODO #9100 */): string { return el.value; }
+  setValue(el: any /** TODO #9100 */, value: string) { el.value = value; }
+  getChecked(el: any /** TODO #9100 */): boolean { return el.checked; }
+  setChecked(el: any /** TODO #9100 */, value: boolean) { el.checked = value; }
   createComment(text: string): Comment { return treeAdapter.createCommentNode(text); }
-  createTemplate(html): HTMLElement {
+  createTemplate(html: any /** TODO #9100 */): HTMLElement {
     var template = treeAdapter.createElement("template", 'http://www.w3.org/1999/xhtml', []);
     var content = parser.parseFragment(html);
     treeAdapter.appendChild(template, content);
     return template;
   }
-  createElement(tagName): HTMLElement {
+  createElement(tagName: any /** TODO #9100 */): HTMLElement {
     return treeAdapter.createElement(tagName, 'http://www.w3.org/1999/xhtml', []);
   }
-  createElementNS(ns, tagName): HTMLElement { return treeAdapter.createElement(tagName, ns, []); }
+  createElementNS(ns: any /** TODO #9100 */, tagName: any /** TODO #9100 */): HTMLElement { return treeAdapter.createElement(tagName, ns, []); }
   createTextNode(text: string): Text {
     var t = <any>this.createComment(text);
     t.type = 'text';
@@ -295,16 +295,16 @@ export class Parse5DomAdapter extends DomAdapter {
     this.setText(style, css);
     return <HTMLStyleElement>style;
   }
-  createShadowRoot(el): HTMLElement {
+  createShadowRoot(el: any /** TODO #9100 */): HTMLElement {
     el.shadowRoot = treeAdapter.createDocumentFragment();
     el.shadowRoot.parent = el;
     return el.shadowRoot;
   }
-  getShadowRoot(el): Element { return el.shadowRoot; }
-  getHost(el): string { return el.host; }
+  getShadowRoot(el: any /** TODO #9100 */): Element { return el.shadowRoot; }
+  getHost(el: any /** TODO #9100 */): string { return el.host; }
   getDistributedNodes(el: any): Node[] { throw _notImplemented('getDistributedNodes'); }
   clone(node: Node): Node {
-    var _recursive = (node) => {
+    var _recursive = (node: any /** TODO #9100 */) => {
       var nodeClone = Object.create(Object.getPrototypeOf(node));
       for (var prop in node) {
         var desc = Object.getOwnPropertyDescriptor(node, prop);
@@ -344,21 +344,21 @@ export class Parse5DomAdapter extends DomAdapter {
     };
     return _recursive(node);
   }
-  getElementsByClassName(element, name: string): HTMLElement[] {
+  getElementsByClassName(element: any /** TODO #9100 */, name: string): HTMLElement[] {
     return this.querySelectorAll(element, "." + name);
   }
   getElementsByTagName(element: any, name: string): HTMLElement[] {
     throw _notImplemented('getElementsByTagName');
   }
-  classList(element): string[] {
-    var classAttrValue = null;
+  classList(element: any /** TODO #9100 */): string[] {
+    var classAttrValue: any /** TODO #9100 */ = null;
     var attributes = element.attribs;
     if (attributes && attributes.hasOwnProperty("class")) {
       classAttrValue = attributes["class"];
     }
     return classAttrValue ? classAttrValue.trim().split(/\s+/g) : [];
   }
-  addClass(element, className: string) {
+  addClass(element: any /** TODO #9100 */, className: string) {
     var classList = this.classList(element);
     var index = classList.indexOf(className);
     if (index == -1) {
@@ -366,7 +366,7 @@ export class Parse5DomAdapter extends DomAdapter {
       element.attribs["class"] = element.className = classList.join(" ");
     }
   }
-  removeClass(element, className: string) {
+  removeClass(element: any /** TODO #9100 */, className: string) {
     var classList = this.classList(element);
     var index = classList.indexOf(className);
     if (index > -1) {
@@ -374,15 +374,15 @@ export class Parse5DomAdapter extends DomAdapter {
       element.attribs["class"] = element.className = classList.join(" ");
     }
   }
-  hasClass(element, className: string): boolean {
+  hasClass(element: any /** TODO #9100 */, className: string): boolean {
     return ListWrapper.contains(this.classList(element), className);
   }
-  hasStyle(element, styleName: string, styleValue: string = null): boolean {
+  hasStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string = null): boolean {
     var value = this.getStyle(element, styleName) || '';
     return styleValue ? value == styleValue : value.length > 0;
   }
   /** @internal */
-  _readStyleAttribute(element) {
+  _readStyleAttribute(element: any /** TODO #9100 */) {
     var styleMap = {};
     var attributes = element.attribs;
     if (attributes && attributes.hasOwnProperty("style")) {
@@ -391,14 +391,14 @@ export class Parse5DomAdapter extends DomAdapter {
       for (var i = 0; i < styleList.length; i++) {
         if (styleList[i].length > 0) {
           var elems = styleList[i].split(/:+/g);
-          styleMap[elems[0].trim()] = elems[1].trim();
+          (styleMap as any /** TODO #9100 */)[elems[0].trim()] = elems[1].trim();
         }
       }
     }
     return styleMap;
   }
   /** @internal */
-  _writeStyleAttribute(element, styleMap) {
+  _writeStyleAttribute(element: any /** TODO #9100 */, styleMap: any /** TODO #9100 */) {
     var styleAttrValue = "";
     for (var key in styleMap) {
       var newValue = styleMap[key];
@@ -408,18 +408,18 @@ export class Parse5DomAdapter extends DomAdapter {
     }
     element.attribs["style"] = styleAttrValue;
   }
-  setStyle(element, styleName: string, styleValue: string) {
+  setStyle(element: any /** TODO #9100 */, styleName: string, styleValue: string) {
     var styleMap = this._readStyleAttribute(element);
-    styleMap[styleName] = styleValue;
+    (styleMap as any /** TODO #9100 */)[styleName] = styleValue;
     this._writeStyleAttribute(element, styleMap);
   }
-  removeStyle(element, styleName: string) { this.setStyle(element, styleName, null); }
-  getStyle(element, styleName: string): string {
+  removeStyle(element: any /** TODO #9100 */, styleName: string) { this.setStyle(element, styleName, null); }
+  getStyle(element: any /** TODO #9100 */, styleName: string): string {
     var styleMap = this._readStyleAttribute(element);
-    return styleMap.hasOwnProperty(styleName) ? styleMap[styleName] : "";
+    return styleMap.hasOwnProperty(styleName) ? (styleMap as any /** TODO #9100 */)[styleName] : "";
   }
-  tagName(element): string { return element.tagName == "style" ? "STYLE" : element.tagName; }
-  attributeMap(element): Map<string, string> {
+  tagName(element: any /** TODO #9100 */): string { return element.tagName == "style" ? "STYLE" : element.tagName; }
+  attributeMap(element: any /** TODO #9100 */): Map<string, string> {
     var res = new Map<string, string>();
     var elAttrs = treeAdapter.getAttrList(element);
     for (var i = 0; i < elAttrs.length; i++) {
@@ -428,17 +428,17 @@ export class Parse5DomAdapter extends DomAdapter {
     }
     return res;
   }
-  hasAttribute(element, attribute: string): boolean {
+  hasAttribute(element: any /** TODO #9100 */, attribute: string): boolean {
     return element.attribs && element.attribs.hasOwnProperty(attribute);
   }
-  hasAttributeNS(element, ns: string, attribute: string): boolean { throw 'not implemented'; }
-  getAttribute(element, attribute: string): string {
+  hasAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): boolean { throw 'not implemented'; }
+  getAttribute(element: any /** TODO #9100 */, attribute: string): string {
     return element.attribs && element.attribs.hasOwnProperty(attribute) ?
                element.attribs[attribute] :
                null;
   }
-  getAttributeNS(element, ns: string, attribute: string): string { throw 'not implemented'; }
-  setAttribute(element, attribute: string, value: string) {
+  getAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string): string { throw 'not implemented'; }
+  setAttribute(element: any /** TODO #9100 */, attribute: string, value: string) {
     if (attribute) {
       element.attribs[attribute] = value;
       if (attribute === 'class') {
@@ -446,14 +446,14 @@ export class Parse5DomAdapter extends DomAdapter {
       }
     }
   }
-  setAttributeNS(element, ns: string, attribute: string, value: string) { throw 'not implemented'; }
-  removeAttribute(element, attribute: string) {
+  setAttributeNS(element: any /** TODO #9100 */, ns: string, attribute: string, value: string) { throw 'not implemented'; }
+  removeAttribute(element: any /** TODO #9100 */, attribute: string) {
     if (attribute) {
       StringMapWrapper.delete(element.attribs, attribute);
     }
   }
-  removeAttributeNS(element, ns: string, name: string) { throw 'not implemented'; }
-  templateAwareRoot(el): any { return this.isTemplateElement(el) ? this.content(el) : el; }
+  removeAttributeNS(element: any /** TODO #9100 */, ns: string, name: string) { throw 'not implemented'; }
+  templateAwareRoot(el: any /** TODO #9100 */): any { return this.isTemplateElement(el) ? this.content(el) : el; }
   createHtmlDocument(): Document {
     var newDoc = treeAdapter.createDocument();
     newDoc.title = "fake title";
@@ -472,21 +472,21 @@ export class Parse5DomAdapter extends DomAdapter {
     }
     return defDoc;
   }
-  getBoundingClientRect(el): any { return {left: 0, top: 0, width: 0, height: 0}; }
+  getBoundingClientRect(el: any /** TODO #9100 */): any { return {left: 0, top: 0, width: 0, height: 0}; }
   getTitle(): string { return this.defaultDoc().title || ""; }
   setTitle(newTitle: string) { this.defaultDoc().title = newTitle; }
   isTemplateElement(el: any): boolean {
     return this.isElementNode(el) && this.tagName(el) === "template";
   }
-  isTextNode(node): boolean { return treeAdapter.isTextNode(node); }
-  isCommentNode(node): boolean { return treeAdapter.isCommentNode(node); }
-  isElementNode(node): boolean { return node ? treeAdapter.isElementNode(node) : false; }
-  hasShadowRoot(node): boolean { return isPresent(node.shadowRoot); }
-  isShadowRoot(node): boolean { return this.getShadowRoot(node) == node; }
-  importIntoDoc(node): any { return this.clone(node); }
-  adoptNode(node): any { return node; }
-  getHref(el): string { return el.href; }
-  resolveAndSetHref(el, baseUrl: string, href: string) {
+  isTextNode(node: any /** TODO #9100 */): boolean { return treeAdapter.isTextNode(node); }
+  isCommentNode(node: any /** TODO #9100 */): boolean { return treeAdapter.isCommentNode(node); }
+  isElementNode(node: any /** TODO #9100 */): boolean { return node ? treeAdapter.isElementNode(node) : false; }
+  hasShadowRoot(node: any /** TODO #9100 */): boolean { return isPresent(node.shadowRoot); }
+  isShadowRoot(node: any /** TODO #9100 */): boolean { return this.getShadowRoot(node) == node; }
+  importIntoDoc(node: any /** TODO #9100 */): any { return this.clone(node); }
+  adoptNode(node: any /** TODO #9100 */): any { return node; }
+  getHref(el: any /** TODO #9100 */): string { return el.href; }
+  resolveAndSetHref(el: any /** TODO #9100 */, baseUrl: string, href: string) {
     if (href == null) {
       el.href = baseUrl;
     } else {
@@ -494,8 +494,8 @@ export class Parse5DomAdapter extends DomAdapter {
     }
   }
   /** @internal */
-  _buildRules(parsedRules, css?) {
-    var rules = [];
+  _buildRules(parsedRules: any /** TODO #9100 */, css?: any /** TODO #9100 */) {
+    var rules: any[] /** TODO #9100 */ = [];
     for (var i = 0; i < parsedRules.length; i++) {
       var parsedRule = parsedRules[i];
       var rule: {[key: string]: any} = StringMapWrapper.create();
@@ -546,12 +546,12 @@ export class Parse5DomAdapter extends DomAdapter {
   getHistory(): History { throw 'not implemented'; }
   getLocation(): Location { throw 'not implemented'; }
   getUserAgent(): string { return "Fake user agent"; }
-  getData(el, name: string): string { return this.getAttribute(el, 'data-' + name); }
-  getComputedStyle(el): any { throw 'not implemented'; }
-  setData(el, name: string, value: string) { this.setAttribute(el, 'data-' + name, value); }
+  getData(el: any /** TODO #9100 */, name: string): string { return this.getAttribute(el, 'data-' + name); }
+  getComputedStyle(el: any /** TODO #9100 */): any { throw 'not implemented'; }
+  setData(el: any /** TODO #9100 */, name: string, value: string) { this.setAttribute(el, 'data-' + name, value); }
   // TODO(tbosch): move this into a separate environment class once we have it
   setGlobalVar(path: string, value: any) { setValueOnPath(global, path, value); }
-  requestAnimationFrame(callback): number { return setTimeout(callback, 0); }
+  requestAnimationFrame(callback: any /** TODO #9100 */): number { return setTimeout(callback, 0); }
   cancelAnimationFrame(id: number) { clearTimeout(id); }
   supportsWebAnimation(): boolean { return false; }
   performanceNow(): number { return DateWrapper.toMillis(DateWrapper.now()); }
@@ -559,10 +559,10 @@ export class Parse5DomAdapter extends DomAdapter {
   getTransitionEnd(): string { return 'transitionend'; }
   supportsAnimation(): boolean { return true; }
 
-  replaceChild(el, newNode, oldNode) { throw new Error('not implemented'); }
+  replaceChild(el: any /** TODO #9100 */, newNode: any /** TODO #9100 */, oldNode: any /** TODO #9100 */) { throw new Error('not implemented'); }
   parse(templateHtml: string) { throw new Error('not implemented'); }
   invoke(el: Element, methodName: string, args: any[]): any { throw new Error('not implemented'); }
-  getEventKey(event): string { throw new Error('not implemented'); }
+  getEventKey(event: any /** TODO #9100 */): string { throw new Error('not implemented'); }
 
   supportsCookies(): boolean { return false; }
   getCookie(name: string): string { throw new Error('not implemented'); }
diff --git a/modules/@angular/router-deprecated/src/directives/router_outlet.ts b/modules/@angular/router-deprecated/src/directives/router_outlet.ts
index de43790893..b188762c38 100644
--- a/modules/@angular/router-deprecated/src/directives/router_outlet.ts
+++ b/modules/@angular/router-deprecated/src/directives/router_outlet.ts
@@ -155,7 +155,7 @@ export class RouterOutlet implements OnDestroy {
    * or resolves to true if the hook is not present.
    */
   routerCanReuse(nextInstruction: ComponentInstruction): Promise<boolean> {
-    var result;
+    var result: any /** TODO #9100 */;
 
     if (isBlank(this._currentInstruction) ||
         this._currentInstruction.componentType != nextInstruction.componentType) {
diff --git a/modules/@angular/router-deprecated/src/instruction.ts b/modules/@angular/router-deprecated/src/instruction.ts
index 5194c26966..bd92df14c3 100644
--- a/modules/@angular/router-deprecated/src/instruction.ts
+++ b/modules/@angular/router-deprecated/src/instruction.ts
@@ -197,7 +197,7 @@ export abstract class Instruction {
 
   /** @internal */
   _stringifyAux(): string {
-    var routes = [];
+    var routes: any[] /** TODO #9100 */ = [];
     StringMapWrapper.forEach(this.auxInstruction, (auxInstruction: Instruction, _: string) => {
       routes.push(auxInstruction._stringifyPathMatrixAux());
     });
@@ -310,7 +310,7 @@ export class ComponentInstruction {
    * @internal
    */
   constructor(public urlPath: string, public urlParams: string[], data: RouteData,
-              public componentType, public terminal: boolean, public specificity: string,
+              public componentType: any /** TODO #9100 */, public terminal: boolean, public specificity: string,
               public params: {[key: string]: string} = null, public routeName: string) {
     this.routeData = isPresent(data) ? data : BLANK_ROUTE_DATA;
   }
diff --git a/modules/@angular/router-deprecated/src/lifecycle/route_lifecycle_reflector.ts b/modules/@angular/router-deprecated/src/lifecycle/route_lifecycle_reflector.ts
index 4f145d3ac5..8476104b4e 100644
--- a/modules/@angular/router-deprecated/src/lifecycle/route_lifecycle_reflector.ts
+++ b/modules/@angular/router-deprecated/src/lifecycle/route_lifecycle_reflector.ts
@@ -2,12 +2,12 @@ import {Type} from '@angular/core';
 import {RouteLifecycleHook, CanActivate} from './lifecycle_annotations_impl';
 import {reflector} from '../../core_private';
 
-export function hasLifecycleHook(e: RouteLifecycleHook, type): boolean {
+export function hasLifecycleHook(e: RouteLifecycleHook, type: any /** TODO #9100 */): boolean {
   if (!(type instanceof Type)) return false;
   return e.name in(<any>type).prototype;
 }
 
-export function getCanActivateHook(type): Function {
+export function getCanActivateHook(type: any /** TODO #9100 */): Function {
   var annotations = reflector.annotations(type);
   for (let i = 0; i < annotations.length; i += 1) {
     let annotation = annotations[i];
diff --git a/modules/@angular/router-deprecated/src/route_config/route_config_normalizer.ts b/modules/@angular/router-deprecated/src/route_config/route_config_normalizer.ts
index 1c365a7b2d..88168e555d 100644
--- a/modules/@angular/router-deprecated/src/route_config/route_config_normalizer.ts
+++ b/modules/@angular/router-deprecated/src/route_config/route_config_normalizer.ts
@@ -90,7 +90,7 @@ export function normalizeRouteConfig(config: RouteDefinition,
 function wrapLoaderToReconfigureRegistry(loader: Function, registry: RouteRegistry): () =>
     Promise<Type> {
   return () => {
-    return loader().then((componentType) => {
+    return loader().then((componentType: any /** TODO #9100 */) => {
       registry.configFromComponent(componentType);
       return componentType;
     });
diff --git a/modules/@angular/router-deprecated/src/route_registry.ts b/modules/@angular/router-deprecated/src/route_registry.ts
index 496856879b..a8c1b6c934 100644
--- a/modules/@angular/router-deprecated/src/route_registry.ts
+++ b/modules/@angular/router-deprecated/src/route_registry.ts
@@ -236,7 +236,7 @@ export class RouteRegistry {
    */
   generate(linkParams: any[], ancestorInstructions: Instruction[], _aux = false): Instruction {
     var params = splitAndFlattenLinkParams(linkParams);
-    var prevInstruction;
+    var prevInstruction: any /** TODO #9100 */;
 
     // The first segment should be either '.' (generate from parent) or '' (generate from root).
     // When we normalize above, we strip all the slashes, './' becomes '.' and '/' becomes ''.
@@ -264,7 +264,7 @@ export class RouteRegistry {
         // we must only peak at the link param, and not consume it
         let routeName = ListWrapper.first(params);
         let parentComponentType = this._rootComponent;
-        let grandparentComponentType = null;
+        let grandparentComponentType: any /** TODO #9100 */ = null;
 
         if (ancestorInstructions.length > 1) {
           let parentComponentInstruction = ancestorInstructions[ancestorInstructions.length - 1];
@@ -333,7 +333,7 @@ export class RouteRegistry {
   private _generate(linkParams: any[], ancestorInstructions: Instruction[],
                     prevInstruction: Instruction, _aux = false, _originalLink: any[]): Instruction {
     let parentComponentType = this._rootComponent;
-    let componentInstruction = null;
+    let componentInstruction: any /** TODO #9100 */ = null;
     let auxInstructions: {[key: string]: Instruction} = {};
 
     let parentInstruction: Instruction = ListWrapper.last(ancestorInstructions);
@@ -456,7 +456,7 @@ export class RouteRegistry {
       return null;
     }
 
-    var defaultChild = null;
+    var defaultChild: any /** TODO #9100 */ = null;
     if (isPresent(rules.defaultRule.handler.componentType)) {
       var componentInstruction = rules.defaultRule.generate({});
       if (!rules.defaultRule.terminal) {
@@ -477,7 +477,7 @@ export class RouteRegistry {
  * Returns: ['', 'a', 'b', {c: 2}]
  */
 function splitAndFlattenLinkParams(linkParams: any[]): any[] {
-  var accumulation = [];
+  var accumulation: any[] /** TODO #9100 */ = [];
   linkParams.forEach(function(item: any) {
     if (isString(item)) {
       var strItem: string = <string>item;
@@ -529,7 +529,7 @@ function compareSpecificityStrings(a: string, b: string): number {
   return a.length - b.length;
 }
 
-function assertTerminalComponent(component, path) {
+function assertTerminalComponent(component: any /** TODO #9100 */, path: any /** TODO #9100 */) {
   if (!isType(component)) {
     return;
   }
diff --git a/modules/@angular/router-deprecated/src/router.ts b/modules/@angular/router-deprecated/src/router.ts
index aef8628843..935498c497 100644
--- a/modules/@angular/router-deprecated/src/router.ts
+++ b/modules/@angular/router-deprecated/src/router.ts
@@ -116,7 +116,7 @@ export class Router {
     this._auxRouters.set(outletName, router);
     router._outlet = outlet;
 
-    var auxInstruction;
+    var auxInstruction: any /** TODO #9100 */;
     if (isPresent(this.currentInstruction) &&
         isPresent(auxInstruction = this.currentInstruction.auxInstruction[outletName])) {
       return router.commit(auxInstruction);
@@ -152,7 +152,7 @@ export class Router {
         return false;
       }
       if (isPresent(instruction.component.params)) {
-        StringMapWrapper.forEach(instruction.component.params, (value, key) => {
+        StringMapWrapper.forEach(instruction.component.params, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => {
           if (currentInstruction.component.params[key] !== value) {
             reason = false;
           }
@@ -254,7 +254,7 @@ export class Router {
         unsettledInstructions.push(this._settleInstruction(instruction.child));
       }
 
-      StringMapWrapper.forEach(instruction.auxInstruction, (instruction: Instruction, _) => {
+      StringMapWrapper.forEach(instruction.auxInstruction, (instruction: Instruction, _: any /** TODO #9100 */) => {
         unsettledInstructions.push(this._settleInstruction(instruction));
       });
       return PromiseWrapper.all(unsettledInstructions);
@@ -547,7 +547,7 @@ export class RootRouter extends Router {
 }
 
 class ChildRouter extends Router {
-  constructor(parent: Router, hostComponent) {
+  constructor(parent: Router, hostComponent: any /** TODO #9100 */) {
     super(parent.registry, parent, hostComponent, parent.root);
     this.parent = parent;
   }
diff --git a/modules/@angular/router-deprecated/src/rules/route_paths/param_route_path.ts b/modules/@angular/router-deprecated/src/rules/route_paths/param_route_path.ts
index d93afed0cc..c4b157342d 100644
--- a/modules/@angular/router-deprecated/src/rules/route_paths/param_route_path.ts
+++ b/modules/@angular/router-deprecated/src/rules/route_paths/param_route_path.ts
@@ -119,7 +119,7 @@ export class ParamRoutePath implements RoutePath {
       if (isPresent(currentUrlSegment)) {
         // the star segment consumes all of the remaining URL, including matrix params
         if (pathSegment instanceof StarPathSegment) {
-          positionalParams[pathSegment.name] = currentUrlSegment.toString();
+          (positionalParams as any /** TODO #9100 */)[pathSegment.name] = currentUrlSegment.toString();
           captured.push(currentUrlSegment.toString());
           nextUrlSegment = null;
           break;
@@ -128,7 +128,7 @@ export class ParamRoutePath implements RoutePath {
         captured.push(currentUrlSegment.path);
 
         if (pathSegment instanceof DynamicPathSegment) {
-          positionalParams[pathSegment.name] = decodeDynamicSegment(currentUrlSegment.path);
+          (positionalParams as any /** TODO #9100 */)[pathSegment.name] = decodeDynamicSegment(currentUrlSegment.path);
         } else if (!pathSegment.match(currentUrlSegment.path)) {
           return null;
         }
@@ -145,8 +145,8 @@ export class ParamRoutePath implements RoutePath {
 
     var urlPath = captured.join('/');
 
-    var auxiliary = [];
-    var urlParams = [];
+    var auxiliary: any[] /** TODO #9100 */ = [];
+    var urlParams: any[] /** TODO #9100 */ = [];
     var allParams = positionalParams;
     if (isPresent(currentUrlSegment)) {
       // If this is the root component, read query params. Otherwise, read matrix params.
@@ -168,7 +168,7 @@ export class ParamRoutePath implements RoutePath {
   generateUrl(params: {[key: string]: any}): GeneratedUrl {
     var paramTokens = new TouchMap(params);
 
-    var path = [];
+    var path: any[] /** TODO #9100 */ = [];
 
     for (var i = 0; i < this._segments.length; i++) {
       let segment = this._segments[i];
@@ -199,7 +199,7 @@ export class ParamRoutePath implements RoutePath {
 
     var limit = segmentStrings.length - 1;
     for (var i = 0; i <= limit; i++) {
-      var segment = segmentStrings[i], match;
+      var segment = segmentStrings[i], match: any /** TODO #9100 */;
 
       if (isPresent(match = RegExpWrapper.firstMatch(DynamicPathSegment.paramMatcher, segment))) {
         this._segments.push(new DynamicPathSegment(match[1]));
@@ -230,7 +230,7 @@ export class ParamRoutePath implements RoutePath {
     // The code below uses place values to combine the different types of segments into a single
     // string that we can sort later. Each static segment is marked as a specificity of "2," each
     // dynamic segment is worth "1" specificity, and stars are worth "0" specificity.
-    var i, length = this._segments.length, specificity;
+    var i: any /** TODO #9100 */, length = this._segments.length, specificity: any /** TODO #9100 */;
     if (length == 0) {
       // a single slash (or "empty segment" is as specific as a static segment
       specificity += '2';
@@ -246,8 +246,8 @@ export class ParamRoutePath implements RoutePath {
   private _calculateHash(): string {
     // this function is used to determine whether a route config path like `/foo/:id` collides with
     // `/foo/:name`
-    var i, length = this._segments.length;
-    var hashParts = [];
+    var i: any /** TODO #9100 */, length = this._segments.length;
+    var hashParts: any[] /** TODO #9100 */ = [];
     for (i = 0; i < length; i++) {
       hashParts.push(this._segments[i].hash);
     }
diff --git a/modules/@angular/router-deprecated/src/rules/rule_set.ts b/modules/@angular/router-deprecated/src/rules/rule_set.ts
index 85f8a8fa59..053c328e75 100644
--- a/modules/@angular/router-deprecated/src/rules/rule_set.ts
+++ b/modules/@angular/router-deprecated/src/rules/rule_set.ts
@@ -44,7 +44,7 @@ export class RuleSet {
    * @returns {boolean} true if the config is terminal
    */
   config(config: RouteDefinition): boolean {
-    let handler;
+    let handler: any /** TODO #9100 */;
 
     if (isPresent(config.name) && config.name[0].toUpperCase() != config.name[0]) {
       let suggestedName = config.name[0].toUpperCase() + config.name.substring(1);
@@ -104,7 +104,7 @@ export class RuleSet {
    * Given a URL, returns a list of `RouteMatch`es, which are partial recognitions for some route.
    */
   recognize(urlParse: Url): Promise<RouteMatch>[] {
-    var solutions = [];
+    var solutions: any[] /** TODO #9100 */ = [];
 
     this.rules.forEach((routeRecognizer: AbstractRule) => {
       var pathMatch = routeRecognizer.recognize(urlParse);
@@ -157,7 +157,7 @@ export class RuleSet {
     return rule.generate(params);
   }
 
-  private _assertNoHashCollision(hash: string, path) {
+  private _assertNoHashCollision(hash: string, path: any /** TODO #9100 */) {
     this.rules.forEach((rule) => {
       if (hash == rule.hash) {
         throw new BaseException(
diff --git a/modules/@angular/router-deprecated/src/rules/rules.ts b/modules/@angular/router-deprecated/src/rules/rules.ts
index b085de7cb4..a450220d32 100644
--- a/modules/@angular/router-deprecated/src/rules/rules.ts
+++ b/modules/@angular/router-deprecated/src/rules/rules.ts
@@ -19,7 +19,7 @@ export class PathMatch extends RouteMatch {
 }
 
 export class RedirectMatch extends RouteMatch {
-  constructor(public redirectTo: any[], public specificity) { super(); }
+  constructor(public redirectTo: any[], public specificity: any /** TODO #9100 */) { super(); }
 }
 
 // Rules are responsible for recognizing URL segments and generating instructions
@@ -44,7 +44,7 @@ export class RedirectRule implements AbstractRule {
    * Returns `null` or a `ParsedUrl` representing the new path to match
    */
   recognize(beginningSegment: Url): Promise<RouteMatch> {
-    var match = null;
+    var match: any /** TODO #9100 */ = null;
     if (isPresent(this._pathRecognizer.matchUrl(beginningSegment))) {
       match = new RedirectMatch(this.redirectTo, this._pathRecognizer.specificity);
     }
diff --git a/modules/@angular/router-deprecated/src/url_parser.ts b/modules/@angular/router-deprecated/src/url_parser.ts
index ef8ae72e97..920d3008aa 100644
--- a/modules/@angular/router-deprecated/src/url_parser.ts
+++ b/modules/@angular/router-deprecated/src/url_parser.ts
@@ -3,12 +3,12 @@ import {isPresent, isBlank, RegExpWrapper} from '../src/facade/lang';
 import {BaseException} from '../src/facade/exceptions';
 
 export function convertUrlParamsToArray(urlParams: {[key: string]: any}): string[] {
-  var paramsArray = [];
+  var paramsArray: any[] /** TODO #9100 */ = [];
   if (isBlank(urlParams)) {
     return [];
   }
   StringMapWrapper.forEach(
-      urlParams, (value, key) => { paramsArray.push((value === true) ? key : key + '=' + value); });
+      urlParams, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => { paramsArray.push((value === true) ? key : key + '=' + value); });
   return paramsArray;
 }
 
@@ -126,7 +126,7 @@ export class UrlParser {
       // TODO: should these params just be dropped?
       this.parseMatrixParams();
     }
-    var child = null;
+    var child: any /** TODO #9100 */ = null;
     if (this.peekStartsWith('/') && !this.peekStartsWith('//')) {
       this.capture('/');
       child = this.parseSegment();
diff --git a/modules/@angular/router-deprecated/src/utils.ts b/modules/@angular/router-deprecated/src/utils.ts
index 33d8efd68e..214bd00d04 100644
--- a/modules/@angular/router-deprecated/src/utils.ts
+++ b/modules/@angular/router-deprecated/src/utils.ts
@@ -7,7 +7,7 @@ export class TouchMap {
 
   constructor(map: {[key: string]: any}) {
     if (isPresent(map)) {
-      StringMapWrapper.forEach(map, (value, key) => {
+      StringMapWrapper.forEach(map, (value: any /** TODO #9100 */, key: any /** TODO #9100 */) => {
         this.map[key] = isPresent(value) ? value.toString() : null;
         this.keys[key] = true;
       });
diff --git a/modules/@angular/router-deprecated/test/directives/router_link_spec.ts b/modules/@angular/router-deprecated/test/directives/router_link_spec.ts
index 5f0717635e..4a7bd94365 100644
--- a/modules/@angular/router-deprecated/test/directives/router_link_spec.ts
+++ b/modules/@angular/router-deprecated/test/directives/router_link_spec.ts
@@ -41,9 +41,9 @@ export function main() {
       {provide: Router, useValue: makeDummyRouter()}
     ]);
 
-    beforeEach(inject([TestComponentBuilder], (tcBuilder) => { tcb = tcBuilder; }));
+    beforeEach(inject([TestComponentBuilder], (tcBuilder: any /** TODO #9100 */) => { tcb = tcBuilder; }));
 
-    it('should update a[href] attribute', inject([AsyncTestCompleter], (async) => {
+    it('should update a[href] attribute', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
          tcb.createAsync(TestComponent)
              .then((testComponent) => {
@@ -57,7 +57,7 @@ export function main() {
 
 
     it('should call router.navigate when a link is clicked',
-       inject([AsyncTestCompleter, Router], (async, router) => {
+       inject([AsyncTestCompleter, Router], (async: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
 
          tcb.createAsync(TestComponent)
              .then((testComponent) => {
@@ -71,7 +71,7 @@ export function main() {
        }));
 
     it('should call router.navigate when a link is clicked if target is _self',
-       inject([AsyncTestCompleter, Router], (async, router) => {
+       inject([AsyncTestCompleter, Router], (async: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
 
          tcb.createAsync(TestComponent)
              .then((testComponent) => {
@@ -84,7 +84,7 @@ export function main() {
        }));
 
     it('should NOT call router.navigate when a link is clicked if target is set to other than _self',
-       inject([AsyncTestCompleter, Router], (async, router) => {
+       inject([AsyncTestCompleter, Router], (async: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
 
          tcb.createAsync(TestComponent)
              .then((testComponent) => {
@@ -130,14 +130,14 @@ class TestComponent {
 
 function makeDummyLocation() {
   var dl = new SpyLocation();
-  dl.spy('prepareExternalUrl').andCallFake((url) => url);
+  dl.spy('prepareExternalUrl').andCallFake((url: any /** TODO #9100 */) => url);
   return dl;
 }
 
 function makeDummyRouter() {
   var dr = new SpyRouter();
-  dr.spy('generate').andCallFake((routeParams) => dummyInstruction);
-  dr.spy('isRouteActive').andCallFake((_) => false);
+  dr.spy('generate').andCallFake((routeParams: any /** TODO #9100 */) => dummyInstruction);
+  dr.spy('isRouteActive').andCallFake((_: any /** TODO #9100 */) => false);
   dr.spy('navigateInstruction');
   return dr;
 }
diff --git a/modules/@angular/router-deprecated/test/integration/bootstrap_spec.ts b/modules/@angular/router-deprecated/test/integration/bootstrap_spec.ts
index fa896ca0f2..c1204cf835 100644
--- a/modules/@angular/router-deprecated/test/integration/bootstrap_spec.ts
+++ b/modules/@angular/router-deprecated/test/integration/bootstrap_spec.ts
@@ -42,8 +42,8 @@ import {MockApplicationRef} from '@angular/core/testing';
 
 // noinspection JSAnnotator
 class DummyConsole implements Console {
-  log(message) {}
-  warn(message) {}
+  log(message: any /** TODO #9100 */) {}
+  warn(message: any /** TODO #9100 */) {}
 }
 
 export function main() {
@@ -56,7 +56,7 @@ export function main() {
 
     // do not refactor out the `bootstrap` functionality. We still want to
     // keep this test around so we can ensure that bootstrap a router works
-    it('should bootstrap a simple app', inject([AsyncTestCompleter], (async) => {
+    it('should bootstrap a simple app', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var fakeDoc = getDOM().createHtmlDocument();
          var el = getDOM().createElement('app-cmp', fakeDoc);
          getDOM().appendChild(fakeDoc.body, el);
@@ -71,7 +71,7 @@ export function main() {
                    ])
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('outer { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('');
                  async.done();
@@ -83,7 +83,7 @@ export function main() {
       beforeEachProviders(() => [{provide: ROUTER_PRIMARY_COMPONENT, useValue: BrokenAppCmp}]);
 
       it('should rethrow exceptions from component constructors',
-         inject([AsyncTestCompleter, TestComponentBuilder], (async, tcb: TestComponentBuilder) => {
+         inject([AsyncTestCompleter, TestComponentBuilder], (async: any /** TODO #9100 */, tcb: TestComponentBuilder) => {
            tcb.createAsync(AppCmp).then((fixture) => {
              var router = fixture.debugElement.componentInstance.router;
              PromiseWrapper.catchError(router.navigateByUrl('/cause-error'), (error) => {
@@ -98,7 +98,7 @@ export function main() {
       beforeEachProviders(() => [{provide: ROUTER_PRIMARY_COMPONENT, useValue: HierarchyAppCmp}]);
 
       it('should change the url without pushing a new history state for back navigations',
-         inject([AsyncTestCompleter, TestComponentBuilder], (async, tcb: TestComponentBuilder) => {
+         inject([AsyncTestCompleter, TestComponentBuilder], (async: any /** TODO #9100 */, tcb: TestComponentBuilder) => {
 
            tcb.createAsync(HierarchyAppCmp)
                .then((fixture) => {
@@ -111,7 +111,7 @@ export function main() {
                    ['/parent/child', 'root { parent { hello } }', false]
                  ];
 
-                 router.subscribe((_) => {
+                 router.subscribe((_: any /** TODO #9100 */) => {
                    var location = fixture.debugElement.componentInstance.location;
                    var element = fixture.debugElement.nativeElement;
                    var path = location.path();
@@ -149,12 +149,12 @@ export function main() {
           () => { return [{provide: ROUTER_PRIMARY_COMPONENT, useValue: HierarchyAppCmp}]; });
 
       it('should bootstrap an app with a hierarchy',
-         inject([AsyncTestCompleter, TestComponentBuilder], (async, tcb: TestComponentBuilder) => {
+         inject([AsyncTestCompleter, TestComponentBuilder], (async: any /** TODO #9100 */, tcb: TestComponentBuilder) => {
 
            tcb.createAsync(HierarchyAppCmp)
                .then((fixture) => {
                  var router = fixture.debugElement.componentInstance.router;
-                 router.subscribe((_) => {
+                 router.subscribe((_: any /** TODO #9100 */) => {
                    expect(fixture.debugElement.nativeElement)
                        .toHaveText('root { parent { hello } }');
                    expect(fixture.debugElement.componentInstance.location.path())
@@ -170,12 +170,12 @@ export function main() {
         beforeEachProviders(() => { return [{provide: APP_BASE_HREF, useValue: '/my/app'}]; });
         it('should bootstrap',
            inject([AsyncTestCompleter, TestComponentBuilder],
-                  (async, tcb: TestComponentBuilder) => {
+                  (async: any /** TODO #9100 */, tcb: TestComponentBuilder) => {
 
                     tcb.createAsync(HierarchyAppCmp)
                         .then((fixture) => {
                           var router = fixture.debugElement.componentInstance.router;
-                          router.subscribe((_) => {
+                          router.subscribe((_: any /** TODO #9100 */) => {
                             expect(fixture.debugElement.nativeElement)
                                 .toHaveText('root { parent { hello } }');
                             expect(fixture.debugElement.componentInstance.location.path())
@@ -194,11 +194,11 @@ export function main() {
           () => { return [{provide: ROUTER_PRIMARY_COMPONENT, useValue: QueryStringAppCmp}]; });
 
       it('should recognize and return querystring params with the injected RouteParams',
-         inject([AsyncTestCompleter, TestComponentBuilder], (async, tcb: TestComponentBuilder) => {
+         inject([AsyncTestCompleter, TestComponentBuilder], (async: any /** TODO #9100 */, tcb: TestComponentBuilder) => {
            tcb.createAsync(QueryStringAppCmp)
                .then((fixture) => {
                  var router = fixture.debugElement.componentInstance.router;
-                 router.subscribe((_) => {
+                 router.subscribe((_: any /** TODO #9100 */) => {
                    fixture.detectChanges();
 
                    expect(fixture.debugElement.nativeElement)
@@ -220,16 +220,16 @@ export function main() {
       beforeEachProviders(() => [{provide: ROUTER_PRIMARY_COMPONENT, useValue: AppCmp}]);
 
       beforeEach(inject([TestComponentBuilder],
-                        (testComponentBuilder) => { tcb = testComponentBuilder; }));
+                        (testComponentBuilder: any /** TODO #9100 */) => { tcb = testComponentBuilder; }));
 
       it('should get a reference and pass data to components loaded inside of outlets',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            tcb.createAsync(AppWithOutletListeners)
                .then(fixture => {
                  let appInstance = fixture.debugElement.componentInstance;
                  let router = appInstance.router;
 
-                 router.subscribe((_) => {
+                 router.subscribe((_: any /** TODO #9100 */) => {
                    fixture.detectChanges();
 
                    expect(appInstance.helloCmp).toBeAnInstanceOf(HelloCmp);
diff --git a/modules/@angular/router-deprecated/test/integration/impl/async_route_spec_impl.ts b/modules/@angular/router-deprecated/test/integration/impl/async_route_spec_impl.ts
index 82e0d1d708..452291dcf7 100644
--- a/modules/@angular/router-deprecated/test/integration/impl/async_route_spec_impl.ts
+++ b/modules/@angular/router-deprecated/test/integration/impl/async_route_spec_impl.ts
@@ -38,18 +38,18 @@ function getLinkElement(rtc: ComponentFixture<any>) {
 }
 
 function asyncRoutesWithoutChildrenWithRouteData() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should inject route data into the component', inject([AsyncTestCompleter], (async) => {
+  it('should inject route data into the component', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -65,7 +65,7 @@ function asyncRoutesWithoutChildrenWithRouteData() {
      }));
 
   it('should inject empty object if the route has no data property',
-     inject([AsyncTestCompleter], (async) => {
+     inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -80,18 +80,18 @@ function asyncRoutesWithoutChildrenWithRouteData() {
 }
 
 function asyncRoutesWithoutChildrenWithoutParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -104,7 +104,7 @@ function asyncRoutesWithoutChildrenWithoutParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -117,7 +117,7 @@ function asyncRoutesWithoutChildrenWithoutParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Hello']">go to hello</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -130,7 +130,7 @@ function asyncRoutesWithoutChildrenWithoutParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Hello']">go to hello</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -139,7 +139,7 @@ function asyncRoutesWithoutChildrenWithoutParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('go to hello | ');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement).toHaveText('go to hello | hello');
                expect(location.urlChanges).toEqual(['/test']);
@@ -153,18 +153,18 @@ function asyncRoutesWithoutChildrenWithoutParams() {
 
 
 function asyncRoutesWithoutChildrenWithParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -177,7 +177,7 @@ function asyncRoutesWithoutChildrenWithParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -190,7 +190,7 @@ function asyncRoutesWithoutChildrenWithParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['User', {name: 'naomi'}]">greet naomi</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -203,7 +203,7 @@ function asyncRoutesWithoutChildrenWithParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['User', {name: 'naomi'}]">greet naomi</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -212,7 +212,7 @@ function asyncRoutesWithoutChildrenWithParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('greet naomi | ');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement).toHaveText('greet naomi | hello naomi');
                expect(location.urlChanges).toEqual(['/user/naomi']);
@@ -224,7 +224,7 @@ function asyncRoutesWithoutChildrenWithParams() {
      }));
 
   it('should navigate between components with different parameters',
-     inject([AsyncTestCompleter], (async) => {
+     inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -245,18 +245,18 @@ function asyncRoutesWithoutChildrenWithParams() {
 
 
 function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -269,7 +269,7 @@ function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -282,7 +282,7 @@ function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -295,7 +295,7 @@ function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent', 'Child']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -304,7 +304,7 @@ function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('nav to child | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('nav to child | outer { inner { hello } }');
@@ -319,18 +319,18 @@ function asyncRoutesWithSyncChildrenWithoutDefaultRoutes() {
 
 
 function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -344,7 +344,7 @@ function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -358,7 +358,7 @@ function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['/Parent']">link to inner</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -372,7 +372,7 @@ function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['/Parent']">link to inner</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -382,7 +382,7 @@ function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('link to inner | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('link to inner | outer { inner { hello } }');
@@ -397,18 +397,18 @@ function asyncRoutesWithSyncChildrenWithDefaultRoutes() {
 
 
 function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
-  var rootTC;
-  var tcb;
-  var rtr;
+  var rootTC: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -422,7 +422,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -436,7 +436,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent', 'Child']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -450,7 +450,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent', 'Child']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -460,7 +460,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
              rootTC.detectChanges();
              expect(rootTC.debugElement.nativeElement).toHaveText('nav to child | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                rootTC.detectChanges();
                expect(rootTC.debugElement.nativeElement)
                    .toHaveText('nav to child | outer { inner { hello } }');
@@ -475,18 +475,18 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes() {
 
 
 function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
-  var rootTC;
-  var tcb;
-  var rtr;
+  var rootTC: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -501,7 +501,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -516,7 +516,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -531,7 +531,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {rootTC = rtc})
            .then((_) => rtr.config([
@@ -542,7 +542,7 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
              rootTC.detectChanges();
              expect(rootTC.debugElement.nativeElement).toHaveText('nav to child | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                rootTC.detectChanges();
                expect(rootTC.debugElement.nativeElement)
                    .toHaveText('nav to child | outer { inner { hello } }');
@@ -557,18 +557,18 @@ function asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes() {
 
 
 function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `{ <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -583,7 +583,7 @@ function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `{ <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -598,7 +598,7 @@ function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Team', {id: 'angular'}, 'User', {name: 'matias'}]">nav to matias</a> { <router-outlet></router-outlet> }`)
@@ -614,7 +614,7 @@ function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Team', {id: 'angular'}, 'User', {name: 'matias'}]">nav to matias</a> { <router-outlet></router-outlet> }`)
@@ -626,7 +626,7 @@ function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('nav to matias {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('nav to matias { team angular | user { hello matias } }');
@@ -640,17 +640,17 @@ function asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes() {
 }
 
 export function registerSpecs() {
-  specs['asyncRoutesWithoutChildrenWithRouteData'] = asyncRoutesWithoutChildrenWithRouteData;
-  specs['asyncRoutesWithoutChildrenWithoutParams'] = asyncRoutesWithoutChildrenWithoutParams;
-  specs['asyncRoutesWithoutChildrenWithParams'] = asyncRoutesWithoutChildrenWithParams;
-  specs['asyncRoutesWithSyncChildrenWithoutDefaultRoutes'] =
+  (specs as any /** TODO #9100 */)['asyncRoutesWithoutChildrenWithRouteData'] = asyncRoutesWithoutChildrenWithRouteData;
+  (specs as any /** TODO #9100 */)['asyncRoutesWithoutChildrenWithoutParams'] = asyncRoutesWithoutChildrenWithoutParams;
+  (specs as any /** TODO #9100 */)['asyncRoutesWithoutChildrenWithParams'] = asyncRoutesWithoutChildrenWithParams;
+  (specs as any /** TODO #9100 */)['asyncRoutesWithSyncChildrenWithoutDefaultRoutes'] =
       asyncRoutesWithSyncChildrenWithoutDefaultRoutes;
-  specs['asyncRoutesWithSyncChildrenWithDefaultRoutes'] =
+  (specs as any /** TODO #9100 */)['asyncRoutesWithSyncChildrenWithDefaultRoutes'] =
       asyncRoutesWithSyncChildrenWithDefaultRoutes;
-  specs['asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes'] =
+  (specs as any /** TODO #9100 */)['asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes'] =
       asyncRoutesWithAsyncChildrenWithoutParamsWithoutDefaultRoutes;
-  specs['asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes'] =
+  (specs as any /** TODO #9100 */)['asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes'] =
       asyncRoutesWithAsyncChildrenWithoutParamsWithDefaultRoutes;
-  specs['asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes'] =
+  (specs as any /** TODO #9100 */)['asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes'] =
       asyncRoutesWithAsyncChildrenWithParamsWithoutDefaultRoutes;
 }
diff --git a/modules/@angular/router-deprecated/test/integration/impl/aux_route_spec_impl.ts b/modules/@angular/router-deprecated/test/integration/impl/aux_route_spec_impl.ts
index 0af4179a6e..6748d18454 100644
--- a/modules/@angular/router-deprecated/test/integration/impl/aux_route_spec_impl.ts
+++ b/modules/@angular/router-deprecated/test/integration/impl/aux_route_spec_impl.ts
@@ -27,14 +27,14 @@ function getLinkElement(rtc: ComponentFixture<any>, linkIndex: number = 0) {
 function auxRoutes() {
   var tcb: TestComponentBuilder;
   var fixture: ComponentFixture<any>;
-  var rtr;
+  var rtr: any /** TODO #9100 */;
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async) => {
+  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -49,7 +49,7 @@ function auxRoutes() {
            });
      }));
 
-  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -64,7 +64,7 @@ function auxRoutes() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
@@ -81,7 +81,7 @@ function auxRoutes() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/', ['Modal']]">open modal</a> | <a [routerLink]="['/Hello']">hello</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
@@ -97,7 +97,7 @@ function auxRoutes() {
 
              var navCount = 0;
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                navCount += 1;
                fixture.detectChanges();
                if (navCount == 1) {
@@ -130,14 +130,14 @@ function auxRoutes() {
 function auxRoutesWithAPrimaryRoute() {
   var tcb: TestComponentBuilder;
   var fixture: ComponentFixture<any>;
-  var rtr;
+  var rtr: any /** TODO #9100 */;
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async) => {
+  it('should recognize and navigate from the URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -152,7 +152,7 @@ function auxRoutesWithAPrimaryRoute() {
            });
      }));
 
-  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate via the link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config([
@@ -167,7 +167,7 @@ function auxRoutesWithAPrimaryRoute() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
@@ -184,7 +184,7 @@ function auxRoutesWithAPrimaryRoute() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Hello', ['Modal']]">open modal</a> | main {<router-outlet></router-outlet>} | aux {<router-outlet name="modal"></router-outlet>}`)
@@ -197,7 +197,7 @@ function auxRoutesWithAPrimaryRoute() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('open modal | main {} | aux {}');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('open modal | main {hello} | aux {modal}');
@@ -211,8 +211,8 @@ function auxRoutesWithAPrimaryRoute() {
 }
 
 export function registerSpecs() {
-  specs['auxRoutes'] = auxRoutes;
-  specs['auxRoutesWithAPrimaryRoute'] = auxRoutesWithAPrimaryRoute;
+  (specs as any /** TODO #9100 */)['auxRoutes'] = auxRoutes;
+  (specs as any /** TODO #9100 */)['auxRoutesWithAPrimaryRoute'] = auxRoutesWithAPrimaryRoute;
 }
 
 
diff --git a/modules/@angular/router-deprecated/test/integration/impl/sync_route_spec_impl.ts b/modules/@angular/router-deprecated/test/integration/impl/sync_route_spec_impl.ts
index e2b7aa94d3..c83d24fefb 100644
--- a/modules/@angular/router-deprecated/test/integration/impl/sync_route_spec_impl.ts
+++ b/modules/@angular/router-deprecated/test/integration/impl/sync_route_spec_impl.ts
@@ -30,18 +30,18 @@ function getLinkElement(rtc: ComponentFixture<any>) {
 }
 
 function syncRoutesWithoutChildrenWithoutParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) =>
@@ -54,7 +54,7 @@ function syncRoutesWithoutChildrenWithoutParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) =>
@@ -67,7 +67,7 @@ function syncRoutesWithoutChildrenWithoutParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Hello']">go to hello</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) =>
@@ -80,7 +80,7 @@ function syncRoutesWithoutChildrenWithoutParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Hello']">go to hello</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) =>
@@ -89,7 +89,7 @@ function syncRoutesWithoutChildrenWithoutParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('go to hello | ');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement).toHaveText('go to hello | hello');
                expect(location.urlChanges).toEqual(['/test']);
@@ -103,18 +103,18 @@ function syncRoutesWithoutChildrenWithoutParams() {
 
 
 function syncRoutesWithoutChildrenWithParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -127,7 +127,7 @@ function syncRoutesWithoutChildrenWithParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -140,7 +140,7 @@ function syncRoutesWithoutChildrenWithParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['User', {name: 'naomi'}]">greet naomi</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -153,7 +153,7 @@ function syncRoutesWithoutChildrenWithParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['User', {name: 'naomi'}]">greet naomi</a> | <router-outlet></router-outlet>`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -162,7 +162,7 @@ function syncRoutesWithoutChildrenWithParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('greet naomi | ');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement).toHaveText('greet naomi | hello naomi');
                expect(location.urlChanges).toEqual(['/user/naomi']);
@@ -174,7 +174,7 @@ function syncRoutesWithoutChildrenWithParams() {
      }));
 
   it('should navigate between components with different parameters',
-     inject([AsyncTestCompleter], (async) => {
+     inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -195,18 +195,18 @@ function syncRoutesWithoutChildrenWithParams() {
 
 
 function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -219,7 +219,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -232,7 +232,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent', 'Child']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -245,7 +245,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['Parent', 'Child']">nav to child</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -254,7 +254,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('nav to child | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('nav to child | outer { inner { hello } }');
@@ -269,18 +269,18 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams() {
 
 
 function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `{ <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -294,7 +294,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `{ <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then((_) => rtr.config(
@@ -308,7 +308,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Team', {id: 'angular'}, 'User', {name: 'matias'}]">nav to matias</a> { <router-outlet></router-outlet> }`)
@@ -323,7 +323,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(
            tcb,
            `<a [routerLink]="['/Team', {id: 'angular'}, 'User', {name: 'matias'}]">nav to matias</a> { <router-outlet></router-outlet> }`)
@@ -334,7 +334,7 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('nav to matias {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('nav to matias { team angular | user { hello matias } }');
@@ -349,18 +349,18 @@ function syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams() {
 
 
 function syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams() {
-  var fixture;
-  var tcb;
-  var rtr;
+  var fixture: any /** TODO #9100 */;
+  var tcb: any /** TODO #9100 */;
+  var rtr: any /** TODO #9100 */;
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
 
-  it('should navigate by URL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then(
@@ -374,7 +374,7 @@ function syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams() {
            });
      }));
 
-  it('should navigate by link DSL', inject([AsyncTestCompleter], (async) => {
+  it('should navigate by link DSL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then(
@@ -388,7 +388,7 @@ function syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams() {
            });
      }));
 
-  it('should generate a link URL', inject([AsyncTestCompleter], (async) => {
+  it('should generate a link URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['/Parent']">link to inner</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then(
@@ -402,7 +402,7 @@ function syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams() {
      }));
 
   it('should navigate from a link click',
-     inject([AsyncTestCompleter, Location], (async, location) => {
+     inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
        compile(tcb, `<a [routerLink]="['/Parent']">link to inner</a> | outer { <router-outlet></router-outlet> }`)
            .then((rtc) => {fixture = rtc})
            .then(
@@ -412,7 +412,7 @@ function syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams() {
              fixture.detectChanges();
              expect(fixture.debugElement.nativeElement).toHaveText('link to inner | outer {  }');
 
-             rtr.subscribe((_) => {
+             rtr.subscribe((_: any /** TODO #9100 */) => {
                fixture.detectChanges();
                expect(fixture.debugElement.nativeElement)
                    .toHaveText('link to inner | outer { inner { hello } }');
@@ -432,7 +432,7 @@ function syncRoutesWithDynamicComponents() {
 
   beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+  beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
     tcb = tcBuilder;
     rtr = router;
   }));
@@ -440,7 +440,7 @@ function syncRoutesWithDynamicComponents() {
 
   it('should work',
      inject([AsyncTestCompleter],
-            (async) => {tcb.createAsync(DynamicLoaderCmp)
+            (async: any /** TODO #9100 */) => {tcb.createAsync(DynamicLoaderCmp)
                             .then((rtc) => {fixture = rtc})
                             .then((_) => rtr.config([new Route({path: '/', component: HelloCmp})]))
                             .then((_) => {
@@ -475,13 +475,13 @@ function syncRoutesWithDynamicComponents() {
 
 
 export function registerSpecs() {
-  specs['syncRoutesWithoutChildrenWithoutParams'] = syncRoutesWithoutChildrenWithoutParams;
-  specs['syncRoutesWithoutChildrenWithParams'] = syncRoutesWithoutChildrenWithParams;
-  specs['syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams'] =
+  (specs as any /** TODO #9100 */)['syncRoutesWithoutChildrenWithoutParams'] = syncRoutesWithoutChildrenWithoutParams;
+  (specs as any /** TODO #9100 */)['syncRoutesWithoutChildrenWithParams'] = syncRoutesWithoutChildrenWithParams;
+  (specs as any /** TODO #9100 */)['syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams'] =
       syncRoutesWithSyncChildrenWithoutDefaultRoutesWithoutParams;
-  specs['syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams'] =
+  (specs as any /** TODO #9100 */)['syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams'] =
       syncRoutesWithSyncChildrenWithoutDefaultRoutesWithParams;
-  specs['syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams'] =
+  (specs as any /** TODO #9100 */)['syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams'] =
       syncRoutesWithSyncChildrenWithDefaultRoutesWithoutParams;
-  specs['syncRoutesWithDynamicComponents'] = syncRoutesWithDynamicComponents;
+  (specs as any /** TODO #9100 */)['syncRoutesWithDynamicComponents'] = syncRoutesWithDynamicComponents;
 }
diff --git a/modules/@angular/router-deprecated/test/integration/lifecycle_hook_spec.ts b/modules/@angular/router-deprecated/test/integration/lifecycle_hook_spec.ts
index 3d0b550af5..408ef17e7d 100644
--- a/modules/@angular/router-deprecated/test/integration/lifecycle_hook_spec.ts
+++ b/modules/@angular/router-deprecated/test/integration/lifecycle_hook_spec.ts
@@ -38,7 +38,7 @@ import {ComponentInstruction} from '../../src/instruction';
 
 import {TEST_ROUTER_PROVIDERS, RootCmp, compile} from './util';
 
-var cmpInstanceCount;
+var cmpInstanceCount: any /** TODO #9100 */;
 var log: string[];
 var eventBus: EventEmitter<any>;
 var completer: PromiseCompleter<any>;
@@ -61,7 +61,7 @@ export function main() {
                         eventBus = new EventEmitter();
                       }));
 
-    it('should call the routerOnActivate hook', inject([AsyncTestCompleter], (async) => {
+    it('should call the routerOnActivate hook', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -75,7 +75,7 @@ export function main() {
        }));
 
     it('should wait for a parent component\'s routerOnActivate hook to resolve before calling its child\'s',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -98,7 +98,7 @@ export function main() {
              });
        }));
 
-    it('should call the routerOnDeactivate hook', inject([AsyncTestCompleter], (async) => {
+    it('should call the routerOnDeactivate hook', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -113,7 +113,7 @@ export function main() {
        }));
 
     it('should wait for a child component\'s routerOnDeactivate hook to resolve before calling its parent\'s',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -139,7 +139,7 @@ export function main() {
        }));
 
     it('should reuse a component when the routerCanReuse hook returns true',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -162,7 +162,7 @@ export function main() {
 
 
     it('should not reuse a component when the routerCanReuse hook returns false',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -185,7 +185,7 @@ export function main() {
 
 
     it('should navigate when routerCanActivate returns true',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -206,7 +206,7 @@ export function main() {
        }));
 
     it('should not navigate when routerCanActivate returns false',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -227,7 +227,7 @@ export function main() {
        }));
 
     it('should navigate away when routerCanDeactivate returns true',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -253,7 +253,7 @@ export function main() {
        }));
 
     it('should not navigate away when routerCanDeactivate returns false',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -280,7 +280,7 @@ export function main() {
 
 
     it('should run activation and deactivation hooks in the correct order',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -307,7 +307,7 @@ export function main() {
              });
        }));
 
-    it('should only run reuse hooks when reusing', inject([AsyncTestCompleter], (async) => {
+    it('should only run reuse hooks when reusing', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -337,7 +337,7 @@ export function main() {
              });
        }));
 
-    it('should not run reuse hooks when not reusing', inject([AsyncTestCompleter], (async) => {
+    it('should not run reuse hooks when not reusing', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
              .then((_) => rtr.navigateByUrl('/reuse-hooks/1'))
diff --git a/modules/@angular/router-deprecated/test/integration/navigation_spec.ts b/modules/@angular/router-deprecated/test/integration/navigation_spec.ts
index 33f7a1a03a..34898af7d1 100644
--- a/modules/@angular/router-deprecated/test/integration/navigation_spec.ts
+++ b/modules/@angular/router-deprecated/test/integration/navigation_spec.ts
@@ -28,26 +28,26 @@ import {
 
 import {TEST_ROUTER_PROVIDERS, RootCmp, compile} from './util';
 
-var cmpInstanceCount;
-var childCmpInstanceCount;
+var cmpInstanceCount: any /** TODO #9100 */;
+var childCmpInstanceCount: any /** TODO #9100 */;
 
 export function main() {
   describe('navigation', () => {
 
     var tcb: TestComponentBuilder;
     var fixture: ComponentFixture<any>;
-    var rtr;
+    var rtr: any /** TODO #9100 */;
 
     beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-    beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+    beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
       tcb = tcBuilder;
       rtr = router;
       childCmpInstanceCount = 0;
       cmpInstanceCount = 0;
     }));
 
-    it('should work in a simple case', inject([AsyncTestCompleter], (async) => {
+    it('should work in a simple case', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/test', component: HelloCmp})]))
@@ -61,7 +61,7 @@ export function main() {
 
 
     it('should navigate between components with different parameters',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/user/:name', component: UserCmp})]))
@@ -78,7 +78,7 @@ export function main() {
              });
        }));
 
-    it('should navigate to child routes', inject([AsyncTestCompleter], (async) => {
+    it('should navigate to child routes', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb, 'outer { <router-outlet></router-outlet> }')
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/a/...', component: ParentCmp})]))
@@ -91,7 +91,7 @@ export function main() {
        }));
 
     it('should navigate to child routes that capture an empty path',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
          compile(tcb, 'outer { <router-outlet></router-outlet> }')
              .then((rtc) => {fixture = rtc})
@@ -105,7 +105,7 @@ export function main() {
        }));
 
     it('should navigate to child routes when the root component has an empty path',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb, 'outer { <router-outlet></router-outlet> }')
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: ParentCmp})]))
@@ -118,7 +118,7 @@ export function main() {
              });
        }));
 
-    it('should navigate to child routes of async routes', inject([AsyncTestCompleter], (async) => {
+    it('should navigate to child routes of async routes', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb, 'outer { <router-outlet></router-outlet> }')
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new AsyncRoute({path: '/a/...', loader: parentLoader})]))
@@ -132,7 +132,7 @@ export function main() {
 
 
     it('should replace state when normalized paths are equal',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => location.setInitialPath("/test/"))
@@ -146,7 +146,7 @@ export function main() {
              });
        }));
 
-    it('should reuse common parent components', inject([AsyncTestCompleter], (async) => {
+    it('should reuse common parent components', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/team/:id/...', component: TeamCmp})]))
@@ -167,7 +167,7 @@ export function main() {
        }));
 
     it('should not reuse children when parent components change',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/team/:id/...', component: TeamCmp})]))
@@ -188,7 +188,7 @@ export function main() {
              });
        }));
 
-    it('should inject route data into component', inject([AsyncTestCompleter], (async) => {
+    it('should inject route data into component', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([
@@ -203,7 +203,7 @@ export function main() {
        }));
 
     it('should inject route data into component with AsyncRoute',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([
@@ -219,7 +219,7 @@ export function main() {
        }));
 
     it('should inject empty object if the route has no data property',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config(
@@ -233,7 +233,7 @@ export function main() {
        }));
 
     it('should fire an event for each activated component',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile(tcb, '<router-outlet (activate)="activatedCmp = $event"></router-outlet>')
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/test', component: HelloCmp})]))
diff --git a/modules/@angular/router-deprecated/test/integration/redirect_route_spec.ts b/modules/@angular/router-deprecated/test/integration/redirect_route_spec.ts
index 5eb5666dc4..91ae8c7ab7 100644
--- a/modules/@angular/router-deprecated/test/integration/redirect_route_spec.ts
+++ b/modules/@angular/router-deprecated/test/integration/redirect_route_spec.ts
@@ -26,19 +26,19 @@ import {Location} from '@angular/common';
 import {TEST_ROUTER_PROVIDERS, RootCmp, compile} from './util';
 import {HelloCmp, GoodbyeCmp, RedirectToParentCmp} from './impl/fixture_components';
 
-var cmpInstanceCount;
-var childCmpInstanceCount;
+var cmpInstanceCount: any /** TODO #9100 */;
+var childCmpInstanceCount: any /** TODO #9100 */;
 
 export function main() {
   describe('redirects', () => {
 
     var tcb: TestComponentBuilder;
     var rootTC: ComponentFixture<any>;
-    var rtr;
+    var rtr: any /** TODO #9100 */;
 
     beforeEachProviders(() => TEST_ROUTER_PROVIDERS);
 
-    beforeEach(inject([TestComponentBuilder, Router], (tcBuilder, router) => {
+    beforeEach(inject([TestComponentBuilder, Router], (tcBuilder: any /** TODO #9100 */, router: any /** TODO #9100 */) => {
       tcb = tcBuilder;
       rtr = router;
       childCmpInstanceCount = 0;
@@ -47,7 +47,7 @@ export function main() {
 
 
     it('should apply when navigating by URL',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {rootTC = rtc})
              .then((_) => rtr.config([
@@ -65,7 +65,7 @@ export function main() {
 
 
     it('should recognize and apply absolute redirects',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {rootTC = rtc})
              .then((_) => rtr.config([
@@ -83,7 +83,7 @@ export function main() {
 
 
     it('should recognize and apply relative child redirects',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {rootTC = rtc})
              .then((_) => rtr.config([
@@ -101,7 +101,7 @@ export function main() {
 
 
     it('should recognize and apply relative parent redirects',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {rootTC = rtc})
              .then((_) => rtr.config([
@@ -119,7 +119,7 @@ export function main() {
 
 
     it('should not redirect when redirect is less specific than other matching routes',
-       inject([AsyncTestCompleter, Location], (async, location) => {
+       inject([AsyncTestCompleter, Location], (async: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          compile(tcb)
              .then((rtc) => {rootTC = rtc})
              .then((_) => rtr.config([
diff --git a/modules/@angular/router-deprecated/test/integration/router_link_spec.ts b/modules/@angular/router-deprecated/test/integration/router_link_spec.ts
index a7f3376dda..0dc068e429 100644
--- a/modules/@angular/router-deprecated/test/integration/router_link_spec.ts
+++ b/modules/@angular/router-deprecated/test/integration/router_link_spec.ts
@@ -54,7 +54,7 @@ export function main() {
     ]);
 
     beforeEach(inject([TestComponentBuilder, Router, Location],
-                      (tcBuilder, rtr: Router, loc: Location) => {
+                      (tcBuilder: any /** TODO #9100 */, rtr: Router, loc: Location) => {
                         tcb = tcBuilder;
                         router = rtr;
                         location = loc;
@@ -67,7 +67,7 @@ export function main() {
     }
 
     it('should generate absolute hrefs that include the base href',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          (<SpyLocation>location).setBaseHref('/my/base');
          compile('<a href="hello" [routerLink]="[\'./User\']"></a>')
              .then((_) => router.config(
@@ -81,7 +81,7 @@ export function main() {
        }));
 
 
-    it('should generate link hrefs without params', inject([AsyncTestCompleter], (async) => {
+    it('should generate link hrefs without params', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile('<a href="hello" [routerLink]="[\'./User\']"></a>')
              .then((_) => router.config(
                        [new Route({path: '/user', component: UserCmp, name: 'User'})]))
@@ -94,7 +94,7 @@ export function main() {
        }));
 
 
-    it('should generate link hrefs with params', inject([AsyncTestCompleter], (async) => {
+    it('should generate link hrefs with params', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile('<a href="hello" [routerLink]="[\'./User\', {name: name}]">{{name}}</a>')
              .then((_) => router.config(
                        [new Route({path: '/user/:name', component: UserCmp, name: 'User'})]))
@@ -109,7 +109,7 @@ export function main() {
        }));
 
     it('should generate link hrefs from a child to its sibling',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then(
                  (_) => router.config(
@@ -123,7 +123,7 @@ export function main() {
        }));
 
     it('should generate link hrefs from a child to its sibling with no leading slash',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config([
                new Route(
@@ -138,7 +138,7 @@ export function main() {
        }));
 
     it('should generate link hrefs to a child with no leading slash',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config([
                new Route({path: '/book/:title/...', component: NoPrefixBookCmp, name: 'Book'})
@@ -152,7 +152,7 @@ export function main() {
        }));
 
     it('should throw when links without a leading slash are ambiguous',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config([
                new Route({path: '/book/:title/...', component: AmbiguousBookCmp, name: 'Book'})
@@ -168,7 +168,7 @@ export function main() {
        }));
 
     it('should generate link hrefs when asynchronously loaded',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config([
                new AsyncRoute({
@@ -186,7 +186,7 @@ export function main() {
        }));
 
     it('should generate relative links preserving the existing parent route',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config(
                        [new Route({path: '/book/:title/...', component: BookCmp, name: 'Book'})]))
@@ -211,7 +211,7 @@ export function main() {
              });
        }));
 
-    it('should generate links to auxiliary routes', inject([AsyncTestCompleter], (async) => {
+    it('should generate links to auxiliary routes', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          compile()
              .then((_) => router.config([new Route({path: '/...', component: AuxLinkCmp})]))
              .then((_) => router.navigateByUrl('/'))
@@ -224,7 +224,7 @@ export function main() {
 
 
     describe('router-link-active CSS class', () => {
-      it('should be added to the associated element', inject([AsyncTestCompleter], (async) => {
+      it('should be added to the associated element', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            router.config([
                    new Route({path: '/child', component: HelloCmp, name: 'Child'}),
                    new Route({path: '/better-child', component: Hello2Cmp, name: 'BetterChild'})
@@ -255,7 +255,7 @@ export function main() {
                });
          }));
 
-      it('should be added to links in child routes', inject([AsyncTestCompleter], (async) => {
+      it('should be added to links in child routes', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            router.config([
                    new Route({path: '/child', component: HelloCmp, name: 'Child'}),
                    new Route({
@@ -297,7 +297,7 @@ export function main() {
          }));
 
       it('should not be added to links in other child routes',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            router.config([
                    new Route({path: '/child', component: HelloCmp, name: 'Child'}),
                    new Route({
@@ -344,14 +344,14 @@ export function main() {
 
     describe('when clicked', () => {
 
-      var clickOnElement = function(view) {
+      var clickOnElement = function(view: any /** TODO #9100 */) {
         var anchorEl = fixture.debugElement.query(By.css('a')).nativeElement;
         var dispatchedEvent = getDOM().createMouseEvent('click');
         getDOM().dispatchEvent(anchorEl, dispatchedEvent);
         return dispatchedEvent;
       };
 
-      it('should navigate to link hrefs without params', inject([AsyncTestCompleter], (async) => {
+      it('should navigate to link hrefs without params', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            compile('<a href="hello" [routerLink]="[\'./User\']"></a>')
                .then((_) => router.config(
                          [new Route({path: '/user', component: UserCmp, name: 'User'})]))
@@ -371,7 +371,7 @@ export function main() {
          }));
 
       it('should navigate to link hrefs in presence of base href',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            (<SpyLocation>location).setBaseHref('/base');
            compile('<a href="hello" [routerLink]="[\'./User\']"></a>')
                .then((_) => router.config(
@@ -401,7 +401,7 @@ function getHref(tc: ComponentFixture<any>) {
 
 @Component({selector: 'my-comp', template: '', directives: [ROUTER_DIRECTIVES]})
 class MyComp7 {
-  name;
+  name: any /** TODO #9100 */;
 }
 
 @Component({selector: 'user-cmp', template: "hello {{user}}"})
diff --git a/modules/@angular/router-deprecated/test/integration/util.ts b/modules/@angular/router-deprecated/test/integration/util.ts
index 2469aa8284..26475ab7b5 100644
--- a/modules/@angular/router-deprecated/test/integration/util.ts
+++ b/modules/@angular/router-deprecated/test/integration/util.ts
@@ -47,13 +47,13 @@ export var TEST_ROUTER_PROVIDERS: any[] = [
   {provide: Router, useClass: RootRouter}
 ];
 
-export function clickOnElement(anchorEl) {
+export function clickOnElement(anchorEl: any /** TODO #9100 */) {
   var dispatchedEvent = getDOM().createMouseEvent('click');
   getDOM().dispatchEvent(anchorEl, dispatchedEvent);
   return dispatchedEvent;
 }
 
-export function getHref(elt) {
+export function getHref(elt: any /** TODO #9100 */) {
   return getDOM().getAttribute(elt, 'href');
 }
 
@@ -62,7 +62,7 @@ export function getHref(elt) {
  * Router integration suite DSL
  */
 
-var specNameBuilder = [];
+var specNameBuilder: any[] /** TODO #9100 */ = [];
 
 // we add the specs themselves onto this map
 export var specs = {};
@@ -110,7 +110,7 @@ function descriptionToSpecName(description: string): string {
 export function itShouldRoute() {
   var specSuiteName = spaceCaseToCamelCase(specNameBuilder.join(' '));
 
-  var spec = specs[specSuiteName];
+  var spec = (specs as any /** TODO #9100 */)[specSuiteName];
   if (isBlank(spec)) {
     throw new BaseException(`Router integration spec suite "${specSuiteName}" was not found.`);
   } else {
diff --git a/modules/@angular/router-deprecated/test/location/hash_location_strategy_spec.ts b/modules/@angular/router-deprecated/test/location/hash_location_strategy_spec.ts
index 4acf16a6b3..0c99ade1a4 100644
--- a/modules/@angular/router-deprecated/test/location/hash_location_strategy_spec.ts
+++ b/modules/@angular/router-deprecated/test/location/hash_location_strategy_spec.ts
@@ -23,7 +23,7 @@ export function main() {
         () => [HashLocationStrategy, {provide: PlatformLocation, useClass: SpyPlatformLocation}]);
 
     describe('without APP_BASE_HREF', () => {
-      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -63,7 +63,7 @@ export function main() {
     describe('with APP_BASE_HREF with neither leading nor trailing slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: 'app'}]);
 
-      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -96,7 +96,7 @@ export function main() {
     describe('with APP_BASE_HREF with leading slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: '/app'}]);
 
-      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -129,7 +129,7 @@ export function main() {
     describe('with APP_BASE_HREF with both leading and trailing slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: '/app/'}]);
 
-      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -160,7 +160,7 @@ export function main() {
     });
 
     describe('hashLocationStrategy bugs', () => {
-      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, HashLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
diff --git a/modules/@angular/router-deprecated/test/location/location_spec.ts b/modules/@angular/router-deprecated/test/location/location_spec.ts
index 6b9538106c..73cf499094 100644
--- a/modules/@angular/router-deprecated/test/location/location_spec.ts
+++ b/modules/@angular/router-deprecated/test/location/location_spec.ts
@@ -17,7 +17,7 @@ import {MockLocationStrategy} from '@angular/common/testing';
 export function main() {
   describe('Location', () => {
 
-    var locationStrategy, location;
+    var locationStrategy: any /** TODO #9100 */, location: any /** TODO #9100 */;
 
     function makeLocation(baseHref: string = '/my/app',
                           provider: any = /*@ts2dart_const*/[]): Location {
@@ -43,9 +43,9 @@ export function main() {
       expect(locationStrategy.path()).toEqual('/my/app/user/btford');
     });
 
-    it('should normalize urls on popstate', inject([AsyncTestCompleter], (async) => {
+    it('should normalize urls on popstate', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
 
-         location.subscribe((ev) => {
+         location.subscribe((ev: any /** TODO #9100 */) => {
            expect(ev['url']).toEqual('/user/btford');
            async.done();
          });
@@ -56,7 +56,7 @@ export function main() {
       var locationStrategy = new MockLocationStrategy();
       var location = new Location(locationStrategy);
 
-      function assertUrl(path) { expect(location.path()).toEqual(path); }
+      function assertUrl(path: any /** TODO #9100 */) { expect(location.path()).toEqual(path); }
 
       location.go('/ready');
       assertUrl('/ready');
diff --git a/modules/@angular/router-deprecated/test/location/path_location_strategy_spec.ts b/modules/@angular/router-deprecated/test/location/path_location_strategy_spec.ts
index 20605210f3..f69316b6c0 100644
--- a/modules/@angular/router-deprecated/test/location/path_location_strategy_spec.ts
+++ b/modules/@angular/router-deprecated/test/location/path_location_strategy_spec.ts
@@ -20,7 +20,7 @@ import {SpyPlatformLocation} from '../spies';
 
 export function main() {
   describe('PathLocationStrategy', () => {
-    var platformLocation, locationStrategy;
+    var platformLocation: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */;
 
     beforeEachProviders(() => [
       PathLocationStrategy,
@@ -38,7 +38,7 @@ export function main() {
     });
 
     describe('without APP_BASE_HREF', () => {
-      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
       }));
@@ -69,7 +69,7 @@ export function main() {
     describe('with APP_BASE_HREF with neither leading nor trailing slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: 'app'}]);
 
-      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -102,7 +102,7 @@ export function main() {
     describe('with APP_BASE_HREF with leading slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: '/app'}]);
 
-      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
@@ -135,7 +135,7 @@ export function main() {
     describe('with APP_BASE_HREF with both leading and trailing slash', () => {
       beforeEachProviders(() => [{provide: APP_BASE_HREF, useValue: '/app/'}]);
 
-      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl, ls) => {
+      beforeEach(inject([PlatformLocation, PathLocationStrategy], (pl: any /** TODO #9100 */, ls: any /** TODO #9100 */) => {
         platformLocation = pl;
         locationStrategy = ls;
         platformLocation.spy('pushState');
diff --git a/modules/@angular/router-deprecated/test/route_config/route_config_spec.ts b/modules/@angular/router-deprecated/test/route_config/route_config_spec.ts
index b29fd0c007..f5b75ac1d9 100644
--- a/modules/@angular/router-deprecated/test/route_config/route_config_spec.ts
+++ b/modules/@angular/router-deprecated/test/route_config/route_config_spec.ts
@@ -31,13 +31,13 @@ class _ArrayLogger {
 }
 
 class DummyConsole implements Console {
-  log(message) {}
-  warn(message) {}
+  log(message: any /** TODO #9100 */) {}
+  warn(message: any /** TODO #9100 */) {}
 }
 
 export function main() {
   describe('RouteConfig with POJO arguments', () => {
-    var fakeDoc, el, testBindings;
+    var fakeDoc: any /** TODO #9100 */, el: any /** TODO #9100 */, testBindings: any /** TODO #9100 */;
     beforeEach(() => {
       fakeDoc = getDOM().createHtmlDocument();
       el = getDOM().createElement('app-cmp', fakeDoc);
@@ -53,11 +53,11 @@ export function main() {
       ];
     });
 
-    it('should bootstrap an app with a hierarchy', inject([AsyncTestCompleter], (async) => {
+    it('should bootstrap an app with a hierarchy', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(HierarchyAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { parent { hello } }');
                  expect(applicationRef.instance.location.path()).toEqual('/parent/child');
                  async.done();
@@ -67,11 +67,11 @@ export function main() {
        }));
 
 
-    it('should work in an app with redirects', inject([AsyncTestCompleter], (async) => {
+    it('should work in an app with redirects', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(RedirectAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('/after');
                  async.done();
@@ -81,11 +81,11 @@ export function main() {
        }));
 
 
-    it('should work in an app with async components', inject([AsyncTestCompleter], (async) => {
+    it('should work in an app with async components', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(AsyncAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('/hello');
                  async.done();
@@ -95,11 +95,11 @@ export function main() {
        }));
 
 
-    it('should work in an app with aux routes', inject([AsyncTestCompleter], (async) => {
+    it('should work in an app with aux routes', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(AuxAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { hello } aside { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('/hello(aside)');
                  async.done();
@@ -110,11 +110,11 @@ export function main() {
 
 
     it('should work in an app with async components defined with "loader"',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(ConciseAsyncAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('/hello');
                  async.done();
@@ -125,11 +125,11 @@ export function main() {
 
 
     it('should work in an app with a constructor component',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          bootstrap(ExplicitConstructorAppCmp, testBindings)
              .then((applicationRef) => {
                var router = applicationRef.instance.router;
-               router.subscribe((_) => {
+               router.subscribe((_: any /** TODO #9100 */) => {
                  expect(el).toHaveText('root { hello }');
                  expect(applicationRef.instance.location.path()).toEqual('/hello');
                  async.done();
@@ -141,7 +141,7 @@ export function main() {
     it('should throw if a config is missing a target',
        inject(
            [AsyncTestCompleter],
-           (async) => {
+           (async: any /** TODO #9100 */) => {
                bootstrap(WrongConfigCmp, testBindings)
                    .catch((e) => {
                      expect(e.originalException)
@@ -154,7 +154,7 @@ export function main() {
     it('should throw if a config has an invalid component type',
        inject(
            [AsyncTestCompleter],
-           (async) => {
+           (async: any /** TODO #9100 */) => {
                bootstrap(WrongComponentTypeCmp, testBindings)
                    .catch((e) => {
                      expect(e.originalException)
@@ -167,7 +167,7 @@ export function main() {
     it('should throw if a config has an invalid alias name',
        inject(
            [AsyncTestCompleter],
-           (async) => {
+           (async: any /** TODO #9100 */) => {
                bootstrap(BadAliasNameCmp, testBindings)
                    .catch((e) => {
                      expect(e.originalException)
diff --git a/modules/@angular/router-deprecated/test/route_registry_spec.ts b/modules/@angular/router-deprecated/test/route_registry_spec.ts
index e276da47dd..19e5de6bb1 100644
--- a/modules/@angular/router-deprecated/test/route_registry_spec.ts
+++ b/modules/@angular/router-deprecated/test/route_registry_spec.ts
@@ -28,7 +28,7 @@ export function main() {
 
     beforeEach(() => { registry = new RouteRegistry(RootHostCmp); });
 
-    it('should match the full URL', inject([AsyncTestCompleter], (async) => {
+    it('should match the full URL', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/', component: DummyCmpA}));
          registry.config(RootHostCmp, new Route({path: '/test', component: DummyCmpB}));
 
@@ -100,7 +100,7 @@ export function main() {
 
 
     it('should generate URLs of loaded components after they are loaded',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(
              RootHostCmp,
              new AsyncRoute({path: '/first/...', loader: asyncParentLoader, name: 'FirstCmp'}));
@@ -131,7 +131,7 @@ export function main() {
           .toEqual('primary(aux)');
     });
 
-    it('should prefer static segments to dynamic', inject([AsyncTestCompleter], (async) => {
+    it('should prefer static segments to dynamic', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/:site', component: DummyCmpB}));
          registry.config(RootHostCmp, new Route({path: '/home', component: DummyCmpA}));
 
@@ -142,7 +142,7 @@ export function main() {
              });
        }));
 
-    it('should prefer dynamic segments to star', inject([AsyncTestCompleter], (async) => {
+    it('should prefer dynamic segments to star', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/:site', component: DummyCmpA}));
          registry.config(RootHostCmp, new Route({path: '/*site', component: DummyCmpB}));
 
@@ -153,7 +153,7 @@ export function main() {
              });
        }));
 
-    it('should prefer routes with more dynamic segments', inject([AsyncTestCompleter], (async) => {
+    it('should prefer routes with more dynamic segments', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/:first/*rest', component: DummyCmpA}));
          registry.config(RootHostCmp, new Route({path: '/*all', component: DummyCmpB}));
 
@@ -164,7 +164,7 @@ export function main() {
              });
        }));
 
-    it('should prefer routes with more static segments', inject([AsyncTestCompleter], (async) => {
+    it('should prefer routes with more static segments', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/first/:second', component: DummyCmpA}));
          registry.config(RootHostCmp, new Route({path: '/:first/:second', component: DummyCmpB}));
 
@@ -176,7 +176,7 @@ export function main() {
        }));
 
     it('should prefer routes with static segments before dynamic segments',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp,
                          new Route({path: '/first/second/:third', component: DummyCmpB}));
          registry.config(RootHostCmp,
@@ -190,7 +190,7 @@ export function main() {
        }));
 
     it('should prefer routes with high specificity over routes with children with lower specificity',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/first', component: DummyCmpA}));
 
          // terminates to DummyCmpB
@@ -204,7 +204,7 @@ export function main() {
              });
        }));
 
-    it('should match the full URL using child components', inject([AsyncTestCompleter], (async) => {
+    it('should match the full URL using child components', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/first/...', component: DummyParentCmp}));
 
          registry.recognize('/first/second', [])
@@ -216,7 +216,7 @@ export function main() {
        }));
 
     it('should match the URL using async child components',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/first/...', component: DummyAsyncCmp}));
 
          registry.recognize('/first/second', [])
@@ -231,7 +231,7 @@ export function main() {
        }));
 
     it('should match the URL using an async parent component',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp,
                          new AsyncRoute({path: '/first/...', loader: asyncParentLoader}));
 
@@ -282,7 +282,7 @@ export function main() {
     });
 
     it('should match matrix params on child components and query params on the root component',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp, new Route({path: '/first/...', component: DummyParentCmp}));
 
          registry.recognize('/first/second;filter=odd?comments=all', [])
@@ -297,7 +297,7 @@ export function main() {
        }));
 
     it('should match query params on the root component even when the next URL segment is null',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          registry.config(RootHostCmp,
                          new Route({path: '/first/...', component: SingleSlashChildCmp}));
 
@@ -334,7 +334,7 @@ export function main() {
   });
 }
 
-function stringifyInstruction(instruction): string {
+function stringifyInstruction(instruction: any /** TODO #9100 */): string {
   return instruction.toRootUrl();
 }
 
diff --git a/modules/@angular/router-deprecated/test/router_spec.ts b/modules/@angular/router-deprecated/test/router_spec.ts
index 5079e36374..9e525e2457 100644
--- a/modules/@angular/router-deprecated/test/router_spec.ts
+++ b/modules/@angular/router-deprecated/test/router_spec.ts
@@ -41,7 +41,7 @@ export function main() {
     }));
 
 
-    it('should navigate based on the initial URL state', inject([AsyncTestCompleter], (async) => {
+    it('should navigate based on the initial URL state', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.config([new Route({path: '/', component: DummyComponent})])
@@ -54,7 +54,7 @@ export function main() {
        }));
 
     it('should activate viewports and update URL on navigate',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -68,7 +68,7 @@ export function main() {
        }));
 
     it('should activate viewports and update URL when navigating via DSL',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -83,7 +83,7 @@ export function main() {
        }));
 
     it('should not push a history change on when navigate is called with skipUrlChange',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -100,7 +100,7 @@ export function main() {
     // This test is disabled because it is flaky.
     // TODO: bford. make this test not flaky and reenable it.
     xit('should replace history when triggered by a hashchange with a redirect',
-        inject([AsyncTestCompleter], (async) => {
+        inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
           var outlet = makeDummyOutlet();
 
           router.registerPrimaryOutlet(outlet)
@@ -119,7 +119,7 @@ export function main() {
         }));
 
     it('should push history when triggered by a hashchange without a redirect',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -136,7 +136,7 @@ export function main() {
 
 
     it('should pass an object containing the component instruction to the router change subscription after a successful navigation',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -152,7 +152,7 @@ export function main() {
        }));
 
     it('should pass an object containing the bad url to the router change subscription after a failed navigation',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -167,7 +167,7 @@ export function main() {
              });
        }));
 
-    it('should navigate after being configured', inject([AsyncTestCompleter], (async) => {
+    it('should navigate after being configured', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -208,7 +208,7 @@ export function main() {
     });
 
     it('should generate an instruction with terminal async routes',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet);
@@ -223,7 +223,7 @@ export function main() {
        }));
 
     it('should return whether a given instruction is active with isRouteActive',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -242,7 +242,7 @@ export function main() {
              });
        }));
 
-    it('should provide the current instruction', inject([AsyncTestCompleter], (async) => {
+    it('should provide the current instruction', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var outlet = makeDummyOutlet();
 
          router.registerPrimaryOutlet(outlet)
@@ -320,7 +320,7 @@ export function main() {
 }
 
 
-function stringifyInstruction(instruction): string {
+function stringifyInstruction(instruction: any /** TODO #9100 */): string {
   return instruction.toRootUrl();
 }
 
@@ -336,10 +336,10 @@ class DummyParentComp {
 
 function makeDummyOutlet(): RouterOutlet {
   var ref = new SpyRouterOutlet();
-  ref.spy('canActivate').andCallFake((_) => PromiseWrapper.resolve(true));
-  ref.spy('routerCanReuse').andCallFake((_) => PromiseWrapper.resolve(false));
-  ref.spy('routerCanDeactivate').andCallFake((_) => PromiseWrapper.resolve(true));
-  ref.spy('activate').andCallFake((_) => PromiseWrapper.resolve(true));
+  ref.spy('canActivate').andCallFake((_: any /** TODO #9100 */) => PromiseWrapper.resolve(true));
+  ref.spy('routerCanReuse').andCallFake((_: any /** TODO #9100 */) => PromiseWrapper.resolve(false));
+  ref.spy('routerCanDeactivate').andCallFake((_: any /** TODO #9100 */) => PromiseWrapper.resolve(true));
+  ref.spy('activate').andCallFake((_: any /** TODO #9100 */) => PromiseWrapper.resolve(true));
   return <any>ref;
 }
 
diff --git a/modules/@angular/router-deprecated/test/rules/route_paths/regex_route_param_spec.ts b/modules/@angular/router-deprecated/test/rules/route_paths/regex_route_param_spec.ts
index 9db5bfcbf8..6585a5b217 100644
--- a/modules/@angular/router-deprecated/test/rules/route_paths/regex_route_param_spec.ts
+++ b/modules/@angular/router-deprecated/test/rules/route_paths/regex_route_param_spec.ts
@@ -12,7 +12,7 @@ import {GeneratedUrl} from '../../../src/rules/route_paths/route_path';
 import {RegexRoutePath} from '../../../src/rules/route_paths/regex_route_path';
 import {parser, Url} from '../../../src/url_parser';
 
-function emptySerializer(params) {
+function emptySerializer(params: any /** TODO #9100 */) {
   return new GeneratedUrl('', {});
 }
 
@@ -37,7 +37,7 @@ export function main() {
     });
 
     it('should generate a url by calling the provided serializer', () => {
-      function serializer(params) {
+      function serializer(params: any /** TODO #9100 */) {
         return new GeneratedUrl(`/a/${params['a']}/b/${params['b']}`, {});
       }
       var rec = new RegexRoutePath('/a/(.+)/b/(.+)$', serializer);
diff --git a/modules/@angular/router-deprecated/test/rules/rule_set_spec.ts b/modules/@angular/router-deprecated/test/rules/rule_set_spec.ts
index 893697f43c..68cda4de3a 100644
--- a/modules/@angular/router-deprecated/test/rules/rule_set_spec.ts
+++ b/modules/@angular/router-deprecated/test/rules/rule_set_spec.ts
@@ -23,7 +23,7 @@ export function main() {
     beforeEach(() => { recognizer = new RuleSet(); });
 
 
-    it('should recognize a static segment', inject([AsyncTestCompleter], (async) => {
+    it('should recognize a static segment', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          recognizer.config(new Route({path: '/test', component: DummyCmpA}));
          recognize(recognizer, '/test')
              .then((solutions: RouteMatch[]) => {
@@ -34,7 +34,7 @@ export function main() {
        }));
 
 
-    it('should recognize a single slash', inject([AsyncTestCompleter], (async) => {
+    it('should recognize a single slash', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          recognizer.config(new Route({path: '/', component: DummyCmpA}));
          recognize(recognizer, '/')
              .then((solutions: RouteMatch[]) => {
@@ -45,7 +45,7 @@ export function main() {
        }));
 
 
-    it('should recognize a dynamic segment', inject([AsyncTestCompleter], (async) => {
+    it('should recognize a dynamic segment', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          recognizer.config(new Route({path: '/user/:name', component: DummyCmpA}));
          recognize(recognizer, '/user/brian')
              .then((solutions: RouteMatch[]) => {
@@ -57,7 +57,7 @@ export function main() {
        }));
 
 
-    it('should recognize a star segment', inject([AsyncTestCompleter], (async) => {
+    it('should recognize a star segment', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          recognizer.config(new Route({path: '/first/*rest', component: DummyCmpA}));
          recognize(recognizer, '/first/second/third')
              .then((solutions: RouteMatch[]) => {
@@ -68,8 +68,8 @@ export function main() {
              });
        }));
 
-    it('should recognize a regex', inject([AsyncTestCompleter], (async) => {
-         function emptySerializer(params): GeneratedUrl { return new GeneratedUrl('', {}); }
+    it('should recognize a regex', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
+         function emptySerializer(params: any /** TODO #9100 */): GeneratedUrl { return new GeneratedUrl('', {}); }
 
          recognizer.config(
              new Route({regex: '^(.+)/(.+)$', serializer: emptySerializer, component: DummyCmpA}));
@@ -83,8 +83,8 @@ export function main() {
              });
        }));
 
-    it('should recognize a regex with named_groups', inject([AsyncTestCompleter], (async) => {
-         function emptySerializer(params): GeneratedUrl { return new GeneratedUrl('', {}); }
+    it('should recognize a regex with named_groups', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
+         function emptySerializer(params: any /** TODO #9100 */): GeneratedUrl { return new GeneratedUrl('', {}); }
 
          recognizer.config(new Route({
            regex: '^(.+)/(.+)$',
@@ -125,7 +125,7 @@ export function main() {
     });
 
 
-    it('should recognize redirects', inject([AsyncTestCompleter], (async) => {
+    it('should recognize redirects', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          recognizer.config(new Route({path: '/b', component: DummyCmpA}));
          recognizer.config(new Redirect({path: '/a', redirectTo: ['B']}));
          recognize(recognizer, '/a')
@@ -155,7 +155,7 @@ export function main() {
 
 
     it('should generate using a serializer', () => {
-      function simpleSerializer(params): GeneratedUrl {
+      function simpleSerializer(params: any /** TODO #9100 */): GeneratedUrl {
         var extra = {c: params['c']};
         return new GeneratedUrl(`/${params['a']}/${params['b']}`, extra);
       }
@@ -190,7 +190,7 @@ export function main() {
 
     describe('params', () => {
       it('should recognize parameters within the URL path',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            recognizer.config(
                new Route({path: 'profile/:name', component: DummyCmpA, name: 'User'}));
            recognize(recognizer, '/profile/matsko?comments=all')
@@ -216,7 +216,7 @@ export function main() {
 
 
       it('should prefer positional params over query params',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            recognizer.config(
                new Route({path: 'profile/:name', component: DummyCmpA, name: 'User'}));
            recognize(recognizer, '/profile/yegor?name=igor')
@@ -229,7 +229,7 @@ export function main() {
 
 
       it('should ignore matrix params for the top-level component',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            recognizer.config(
                new Route({path: '/home/:subject', component: DummyCmpA, name: 'User'}));
            recognize(recognizer, '/home;sort=asc/zero;one=1?two=2')
diff --git a/modules/@angular/router-deprecated/testing.ts b/modules/@angular/router-deprecated/testing.ts
index 2effd783a4..40a4255087 100644
--- a/modules/@angular/router-deprecated/testing.ts
+++ b/modules/@angular/router-deprecated/testing.ts
@@ -1,2 +1,2 @@
 // future location of testing for router.
-export var __nothing__;
+export var __nothing__: any /** TODO #9100 */;
diff --git a/modules/@angular/router/src/link.ts b/modules/@angular/router/src/link.ts
index 0e0c0f72ac..9fc317323a 100644
--- a/modules/@angular/router/src/link.ts
+++ b/modules/@angular/router/src/link.ts
@@ -39,7 +39,7 @@ function _normalizeCommands(commands: any[]): _NormalizedNavigationCommands {
 
   let numberOfDoubleDots = 0;
   let isAbsolute = false;
-  let res = [];
+  let res: any[] /** TODO #9100 */ = [];
 
   for (let i = 0; i < commands.length; ++i) {
     let c = commands[i];
@@ -167,7 +167,7 @@ function _update(node: TreeNode<UrlSegment>, commands: any[]): TreeNode<UrlSegme
 
 function _stringify(params: {[key: string]: any}): {[key: string]: string} {
   let res = {};
-  StringMapWrapper.forEach(params, (v, k) => res[k] = v.toString());
+  StringMapWrapper.forEach(params, (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => (res as any /** TODO #9100 */)[k] = v.toString());
   return res;
 }
 
diff --git a/modules/@angular/router/src/recognize.ts b/modules/@angular/router/src/recognize.ts
index 5ca4437a89..b98881173d 100644
--- a/modules/@angular/router/src/recognize.ts
+++ b/modules/@angular/router/src/recognize.ts
@@ -32,7 +32,7 @@ function _recognize(componentResolver: ComponentResolver, parentComponent: Type,
         `Component '${stringify(parentComponent)}' does not have route configuration`);
   }
 
-  let match;
+  let match: any /** TODO #9100 */;
   try {
     match = _match(metadata, url);
   } catch (e) {
@@ -146,7 +146,7 @@ function _matchWithParts(route: RouteMetadata, url: TreeNode<UrlSegment>): _Matc
 
   let parts = path.split("/");
   let positionalParams = {};
-  let consumedUrlSegments = [];
+  let consumedUrlSegments: any[] /** TODO #9100 */ = [];
 
   let lastParent: TreeNode<UrlSegment> = null;
   let lastSegment: TreeNode<UrlSegment> = null;
@@ -169,7 +169,7 @@ function _matchWithParts(route: RouteMetadata, url: TreeNode<UrlSegment>): _Matc
     }
 
     if (isPosParam) {
-      positionalParams[p.substring(1)] = current.value.segment;
+      (positionalParams as any /** TODO #9100 */)[p.substring(1)] = current.value.segment;
     }
 
     consumedUrlSegments.push(current.value);
@@ -188,13 +188,13 @@ function _matchWithParts(route: RouteMetadata, url: TreeNode<UrlSegment>): _Matc
 function _checkOutletNameUniqueness(nodes: TreeNode<RouteSegment>[]): TreeNode<RouteSegment>[] {
   let names = {};
   nodes.forEach(n => {
-    let segmentWithSameOutletName = names[n.value.outlet];
+    let segmentWithSameOutletName = (names as any /** TODO #9100 */)[n.value.outlet];
     if (isPresent(segmentWithSameOutletName)) {
       let p = segmentWithSameOutletName.stringifiedUrlSegments;
       let c = n.value.stringifiedUrlSegments;
       throw new BaseException(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
     }
-    names[n.value.outlet] = n.value;
+    (names as any /** TODO #9100 */)[n.value.outlet] = n.value;
   });
   return nodes;
 }
diff --git a/modules/@angular/router/src/router.ts b/modules/@angular/router/src/router.ts
index 098fe682cb..cdfa80173b 100644
--- a/modules/@angular/router/src/router.ts
+++ b/modules/@angular/router/src/router.ts
@@ -219,19 +219,19 @@ class _ActivateSegments {
     let prevChildren = isPresent(prevNode) ?
                            prevNode.children.reduce(
                                (m, c) => {
-                                 m[c.value.outlet] = c;
+                                 (m as any /** TODO #9100 */)[c.value.outlet] = c;
                                  return m;
                                },
                                {}) :
                            {};
 
     currNode.children.forEach(c => {
-      this.activateSegments(c, prevChildren[c.value.outlet], outletMap, components);
+      this.activateSegments(c, (prevChildren as any /** TODO #9100 */)[c.value.outlet], outletMap, components);
       StringMapWrapper.delete(prevChildren, c.value.outlet);
     });
 
     StringMapWrapper.forEach(prevChildren,
-                             (v, k) => this.deactivateOutlet(outletMap._outlets[k], components));
+                             (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => this.deactivateOutlet(outletMap._outlets[k], components));
   }
 
   activateSegments(currNode: TreeNode<RouteSegment>, prevNode: TreeNode<RouteSegment>,
@@ -279,7 +279,7 @@ class _ActivateSegments {
   private deactivateOutlet(outlet: RouterOutlet, components: Object[]): void {
     if (isPresent(outlet) && outlet.isActivated) {
       StringMapWrapper.forEach(outlet.outletMap._outlets,
-                               (v, k) => this.deactivateOutlet(v, components));
+                               (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => this.deactivateOutlet(v, components));
       if (this.performMutation) {
         outlet.deactivate();
       } else {
diff --git a/modules/@angular/router/src/router_url_serializer.ts b/modules/@angular/router/src/router_url_serializer.ts
index 1d05564a95..6ea37dc58f 100644
--- a/modules/@angular/router/src/router_url_serializer.ts
+++ b/modules/@angular/router/src/router_url_serializer.ts
@@ -108,7 +108,7 @@ class _UrlParser {
       matrixParams = this.parseMatrixParams();
     }
 
-    var aux = [];
+    var aux: any[] /** TODO #9100 */ = [];
     if (this.peekStartsWith('(')) {
       aux = this.parseAuxiliaryRoutes();
     }
@@ -183,7 +183,7 @@ class _UrlParser {
   }
 
   parseAuxiliaryRoutes(): TreeNode<UrlSegment>[] {
-    var segments = [];
+    var segments: any[] /** TODO #9100 */ = [];
     this.capture('(');
 
     while (!this.peekStartsWith(')') && this._remaining.length > 0) {
diff --git a/modules/@angular/router/src/segments.ts b/modules/@angular/router/src/segments.ts
index 05ad6d1a4e..4b2431808d 100644
--- a/modules/@angular/router/src/segments.ts
+++ b/modules/@angular/router/src/segments.ts
@@ -92,7 +92,7 @@ export class UrlSegment {
 
 function _serializeParams(params: {[key: string]: string}): string {
   let res = "";
-  StringMapWrapper.forEach(params, (v, k) => res += `;${k}=${v}`);
+  StringMapWrapper.forEach(params, (v: any /** TODO #9100 */, k: any /** TODO #9100 */) => res += `;${k}=${v}`);
   return res;
 }
 
diff --git a/modules/@angular/router/test/integration_spec.ts b/modules/@angular/router/test/integration_spec.ts
index 3858010709..791c1d45cb 100644
--- a/modules/@angular/router/test/integration_spec.ts
+++ b/modules/@angular/router/test/integration_spec.ts
@@ -39,17 +39,17 @@ export function main() {
       {provide: RouterUrlSerializer, useClass: DefaultRouterUrlSerializer},
       RouterOutletMap,
       {provide: Location, useClass: SpyLocation},
-      {provide: RouteSegment, useFactory: (r) => r.routeTree.root, deps: [Router]},
+      {provide: RouteSegment, useFactory: (r: any /** TODO #9100 */) => r.routeTree.root, deps: [Router]},
       {
         provide: Router,
-        useFactory: (resolver, urlParser, outletMap, location) => new Router(
+        useFactory: (resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */, outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) => new Router(
                         "RootComponent", RootCmp, resolver, urlParser, outletMap, location),
         deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
       }
     ]);
 
     it('should update location when navigating',
-       fakeAsync(inject([Router, TestComponentBuilder, Location], (router, tcb, location) => {
+       fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor');
@@ -63,7 +63,7 @@ export function main() {
        })));
 
     it('should navigate back and forward',
-      fakeAsync(inject([Router, TestComponentBuilder, Location], (router, tcb, location) => {
+      fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
         let fixture = tcb.createFakeAsync(RootCmp);
 
         router.navigateByUrl('/team/33/simple');
@@ -82,7 +82,7 @@ export function main() {
       })));
 
     it('should navigate when locations changes',
-       fakeAsync(inject([Router, TestComponentBuilder, Location], (router, tcb, location) => {
+       fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor');
@@ -95,7 +95,7 @@ export function main() {
        })));
 
     it('should support nested routes',
-       fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+       fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor');
@@ -105,7 +105,7 @@ export function main() {
        })));
 
     it('should support aux routes',
-       fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+       fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor(/simple)');
@@ -116,7 +116,7 @@ export function main() {
        })));
 
     it('should deactivate outlets',
-       fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+       fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor(/simple)');
@@ -129,7 +129,7 @@ export function main() {
        })));
 
     it('should deactivate nested outlets',
-       fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+       fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor(/simple)');
@@ -142,7 +142,7 @@ export function main() {
        })));
 
     it('should update nested routes when url changes',
-       fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+       fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/user/victor');
@@ -158,7 +158,7 @@ export function main() {
        })));
 
     it('should not deactivate the route if can deactivate returns false',
-       fakeAsync(inject([Router, TestComponentBuilder, Location], (router, tcb, location) => {
+       fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
          let fixture = tcb.createFakeAsync(RootCmp);
 
          router.navigateByUrl('/team/22/cannotDeactivate');
@@ -175,7 +175,7 @@ export function main() {
 
     if (getDOM().supportsDOMEvents()) {
       it("should support absolute router links",
-         fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+         fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
            let fixture = tcb.createFakeAsync(RootCmp);
            advance(fixture);
 
@@ -192,7 +192,7 @@ export function main() {
          })));
 
       it("should support relative router links",
-         fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+         fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
            let fixture = tcb.createFakeAsync(RootCmp);
            advance(fixture);
 
@@ -211,7 +211,7 @@ export function main() {
          })));
 
       it("should set the router-link-active class",
-         fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+         fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
            let fixture = tcb.createFakeAsync(RootCmp);
            advance(fixture);
 
@@ -229,7 +229,7 @@ export function main() {
          })));
 
       it("should update router links when router changes",
-         fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+         fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
            let fixture = tcb.createFakeAsync(RootCmp);
            advance(fixture);
 
@@ -247,14 +247,14 @@ export function main() {
          })));
 
       it("should support top-level link",
-         fakeAsync(inject([Router, TestComponentBuilder], (router, tcb) => {
+         fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
            let fixture = tcb.createFakeAsync(LinkCmp);
            advance(fixture);
            expect(fixture.debugElement.nativeElement).toHaveText('link');
          })));
 
       it('should replace state when path is equal to current path',
-        fakeAsync(inject([Router, TestComponentBuilder, Location], (router, tcb, location) => {
+        fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
           let fixture = tcb.createFakeAsync(RootCmp);
 
           router.navigateByUrl('/team/33/simple');
@@ -286,12 +286,12 @@ function compileRoot(tcb: TestComponentBuilder): Promise<ComponentFixture<any>>
 @Component({selector: 'user-cmp', template: `hello {{user}}`})
 class UserCmp implements OnActivate {
   user: string;
-  routerOnActivate(s: RouteSegment, a?, b?, c?) { this.user = s.getParam('name'); }
+  routerOnActivate(s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */, c?: any /** TODO #9100 */) { this.user = s.getParam('name'); }
 }
 
 @Component({selector: 'cannot-deactivate', template: `cannotDeactivate`})
 class CanDeactivateCmp implements CanDeactivate {
-  routerCanDeactivate(a?, b?): Promise<boolean> { return PromiseWrapper.resolve(false); }
+  routerCanDeactivate(a?: any /** TODO #9100 */, b?: any /** TODO #9100 */): Promise<boolean> { return PromiseWrapper.resolve(false); }
 }
 
 @Component({selector: 'simple-cmp', template: `simple`})
@@ -334,7 +334,7 @@ class RelativeLinkCmp {
 ])
 class TeamCmp implements OnActivate {
   id: string;
-  routerOnActivate(s: RouteSegment, a?, b?, c?) { this.id = s.getParam('id'); }
+  routerOnActivate(s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */, c?: any /** TODO #9100 */) { this.id = s.getParam('id'); }
 }
 
 @Component({
diff --git a/modules/@angular/router/test/recognize_spec.ts b/modules/@angular/router/test/recognize_spec.ts
index 8c6110c385..a7e243497e 100644
--- a/modules/@angular/router/test/recognize_spec.ts
+++ b/modules/@angular/router/test/recognize_spec.ts
@@ -24,7 +24,7 @@ export function main() {
     let emptyRouteTree = createEmptyRouteTree(ComponentA);
 
     it('should handle position args',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b/paramB/c/paramC/d"), emptyRouteTree)
              .then(r => {
                let a = r.root;
@@ -48,7 +48,7 @@ export function main() {
        }));
 
     it('should support empty routes',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("f"), emptyRouteTree)
              .then(r => {
                let a = r.root;
@@ -68,7 +68,7 @@ export function main() {
        }));
 
     it('should handle aux routes',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b/paramB(/d//right:d)"), emptyRouteTree)
              .then(r => {
                let c = r.children(r.root);
@@ -89,7 +89,7 @@ export function main() {
        }));
 
     it("should error when two segments with the same outlet name",
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b/paramB(right:d//right:e)"), emptyRouteTree)
              .catch(e => {
                expect(e.message).toEqual(
@@ -99,7 +99,7 @@ export function main() {
        }));
 
     it('should handle nested aux routes',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b/paramB(/d(right:e))"), emptyRouteTree)
              .then(r => {
                let c = r.children(r.root);
@@ -120,7 +120,7 @@ export function main() {
        }));
 
     it('should handle non top-level aux routes',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree('b/paramB/d(e)'), emptyRouteTree)
              .then(r => {
                let c = r.children(r.firstChild(r.root));
@@ -137,7 +137,7 @@ export function main() {
        }));
 
     it('should handle matrix parameters',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b/paramB;b1=1;b2=2(/d;d1=1;d2=2)"), emptyRouteTree)
              .then(r => {
                let c = r.children(r.root);
@@ -149,7 +149,7 @@ export function main() {
        }));
 
     it('should match a wildcard',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentG, tree("a;aa=1/b;bb=2"), emptyRouteTree)
              .then(r => {
                let c = r.children(r.root);
@@ -162,7 +162,7 @@ export function main() {
        }));
 
     it('should error when no matching routes',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("invalid"), emptyRouteTree)
              .catch(e => {
                expect(e.message).toContain("Cannot match any routes");
@@ -171,7 +171,7 @@ export function main() {
        }));
 
     it('should handle no matching routes (too short)',
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("b"), emptyRouteTree)
              .catch(e => {
                expect(e.message).toContain("Cannot match any routes");
@@ -180,7 +180,7 @@ export function main() {
        }));
 
     it("should error when a component doesn't have @Routes",
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("d/invalid"), emptyRouteTree)
              .catch(e => {
                expect(e.message)
@@ -190,7 +190,7 @@ export function main() {
        }));
 
     it("should reuse existing segments",
-       inject([AsyncTestCompleter, ComponentResolver], (async, resolver) => {
+       inject([AsyncTestCompleter, ComponentResolver], (async: any /** TODO #9100 */, resolver: any /** TODO #9100 */) => {
          recognize(resolver, ComponentA, tree("/b/1/d"), emptyRouteTree)
              .then(t1 => {
                recognize(resolver, ComponentA, tree("/b/1/e"), t1)
diff --git a/modules/@angular/router/test/router_link_spec.ts b/modules/@angular/router/test/router_link_spec.ts
index c84d428677..af1d7d69ba 100644
--- a/modules/@angular/router/test/router_link_spec.ts
+++ b/modules/@angular/router/test/router_link_spec.ts
@@ -38,20 +38,20 @@ export function main() {
       {provide: LocationStrategy, useClass: MockLocationStrategy},
       {
         provide: Router,
-        useFactory: (resolver, urlParser, outletMap, location) => new Router(
+        useFactory: (resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */, outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) => new Router(
                      "RootComponent", RootCmp, resolver, urlParser, outletMap, location),
         deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
       }
     ]);
 
     describe("routerLink=", () => {
-      it("should accept an array of commands", inject([Router, LocationStrategy], (router, locationStrategy) => {
+      it("should accept an array of commands", inject([Router, LocationStrategy], (router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
            let link = new RouterLink(null, router, locationStrategy);
            link.routerLink = ['/one', 11];
            expect(link.href).toEqual("/one/11");
          }));
 
-      it("should accept a single command", inject([Router, LocationStrategy], (router, locationStrategy) => {
+      it("should accept a single command", inject([Router, LocationStrategy], (router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
            let link = new RouterLink(null, router, locationStrategy);
            link.routerLink = '/one/11';
            expect(link.href).toEqual("/one/11");
diff --git a/modules/@angular/router/testing/router_testing_providers.ts b/modules/@angular/router/testing/router_testing_providers.ts
index b08a498623..e0f0b6a90f 100644
--- a/modules/@angular/router/testing/router_testing_providers.ts
+++ b/modules/@angular/router/testing/router_testing_providers.ts
@@ -25,5 +25,5 @@ export const ROUTER_FAKE_PROVIDERS: any[] = /*@ts2dart_const*/ [
     deps: /*@ts2dart_const*/
         [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
   },
-  /*@ts2dart_Provider*/ {provide: RouteSegment, useFactory: (r) => r.routeTree.root, deps: [Router]}
+  /*@ts2dart_Provider*/ {provide: RouteSegment, useFactory: (r: any /** TODO #9100 */) => r.routeTree.root, deps: [Router]}
 ];
diff --git a/modules/@angular/upgrade/src/downgrade_ng2_adapter.ts b/modules/@angular/upgrade/src/downgrade_ng2_adapter.ts
index 180309efb7..a377aef13f 100644
--- a/modules/@angular/upgrade/src/downgrade_ng2_adapter.ts
+++ b/modules/@angular/upgrade/src/downgrade_ng2_adapter.ts
@@ -53,11 +53,11 @@ export class DowngradeNg2ComponentAdapter {
     var inputs = this.info.inputs;
     for (var i = 0; i < inputs.length; i++) {
       var input = inputs[i];
-      var expr = null;
+      var expr: any /** TODO #9100 */ = null;
       if (attrs.hasOwnProperty(input.attr)) {
-        var observeFn = ((prop) => {
+        var observeFn = ((prop: any /** TODO #9100 */) => {
           var prevValue = INITIAL_VALUE;
-          return (value) => {
+          return (value: any /** TODO #9100 */) => {
             if (this.inputChanges !== null) {
               this.inputChangeCount++;
               this.inputChanges[prop] =
@@ -69,16 +69,16 @@ export class DowngradeNg2ComponentAdapter {
         })(input.prop);
         attrs.$observe(input.attr, observeFn);
       } else if (attrs.hasOwnProperty(input.bindAttr)) {
-        expr = attrs[input.bindAttr];
+        expr = (attrs as any /** TODO #9100 */)[input.bindAttr];
       } else if (attrs.hasOwnProperty(input.bracketAttr)) {
-        expr = attrs[input.bracketAttr];
+        expr = (attrs as any /** TODO #9100 */)[input.bracketAttr];
       } else if (attrs.hasOwnProperty(input.bindonAttr)) {
-        expr = attrs[input.bindonAttr];
+        expr = (attrs as any /** TODO #9100 */)[input.bindonAttr];
       } else if (attrs.hasOwnProperty(input.bracketParenAttr)) {
-        expr = attrs[input.bracketParenAttr];
+        expr = (attrs as any /** TODO #9100 */)[input.bracketParenAttr];
       }
       if (expr != null) {
-        var watchFn = ((prop) => (value, prevValue) => {
+        var watchFn = ((prop: any /** TODO #9100 */) => (value: any /** TODO #9100 */, prevValue: any /** TODO #9100 */) => {
           if (this.inputChanges != null) {
             this.inputChangeCount++;
             this.inputChanges[prop] = new Ng1Change(prevValue, value);
@@ -117,7 +117,7 @@ export class DowngradeNg2ComponentAdapter {
     var outputs = this.info.outputs;
     for (var j = 0; j < outputs.length; j++) {
       var output = outputs[j];
-      var expr = null;
+      var expr: any /** TODO #9100 */ = null;
       var assignExpr = false;
 
       var bindonAttr =
@@ -128,14 +128,14 @@ export class DowngradeNg2ComponentAdapter {
               null;
 
       if (attrs.hasOwnProperty(output.onAttr)) {
-        expr = attrs[output.onAttr];
+        expr = (attrs as any /** TODO #9100 */)[output.onAttr];
       } else if (attrs.hasOwnProperty(output.parenAttr)) {
-        expr = attrs[output.parenAttr];
+        expr = (attrs as any /** TODO #9100 */)[output.parenAttr];
       } else if (attrs.hasOwnProperty(bindonAttr)) {
-        expr = attrs[bindonAttr];
+        expr = (attrs as any /** TODO #9100 */)[bindonAttr];
         assignExpr = true;
       } else if (attrs.hasOwnProperty(bracketParenAttr)) {
-        expr = attrs[bracketParenAttr];
+        expr = (attrs as any /** TODO #9100 */)[bracketParenAttr];
         assignExpr = true;
       }
 
@@ -148,8 +148,8 @@ export class DowngradeNg2ComponentAdapter {
         var emitter = this.component[output.prop] as EventEmitter<any>;
         if (emitter) {
           emitter.subscribe({
-            next: assignExpr ? ((setter: any) => v => setter(this.scope, v))(setter) :
-                               ((getter: any) => v => getter(this.scope, {$event: v}))(getter)
+            next: assignExpr ? ((setter: any) => (v: any /** TODO #9100 */) => setter(this.scope, v))(setter) :
+                               ((getter: any) => (v: any /** TODO #9100 */) => getter(this.scope, {$event: v}))(getter)
           });
         } else {
           throw new Error(`Missing emitter '${output.prop}' on component '${this.info.selector}'!`);
diff --git a/modules/@angular/upgrade/src/metadata.ts b/modules/@angular/upgrade/src/metadata.ts
index 24594f00a6..a2f2218836 100644
--- a/modules/@angular/upgrade/src/metadata.ts
+++ b/modules/@angular/upgrade/src/metadata.ts
@@ -29,7 +29,7 @@ export function getComponentInfo(type: Type): ComponentInfo {
   if (!selector.match(COMPONENT_SELECTOR)) {
     throw new Error('Only selectors matching element names are supported, got: ' + selector);
   }
-  var selector = selector.replace(SKEWER_CASE, (all, letter: string) => letter.toUpperCase());
+  var selector = selector.replace(SKEWER_CASE, (all: any /** TODO #9100 */, letter: string) => letter.toUpperCase());
   return {
     type: type,
     selector: selector,
diff --git a/modules/@angular/upgrade/src/upgrade_adapter.ts b/modules/@angular/upgrade/src/upgrade_adapter.ts
index e8566aa435..5d60883d43 100644
--- a/modules/@angular/upgrade/src/upgrade_adapter.ts
+++ b/modules/@angular/upgrade/src/upgrade_adapter.ts
@@ -319,14 +319,14 @@ export class UpgradeAdapter {
         .config([
           '$provide',
           '$injector',
-          (provide, ng1Injector) => {
+          (provide: any /** TODO #???? */, ng1Injector: any /** TODO #???? */) => {
             provide.decorator(NG1_ROOT_SCOPE, [
               '$delegate',
               function(rootScopeDelegate: angular.IRootScopeService) {
                 rootScopePrototype = rootScopeDelegate.constructor.prototype;
                 if (rootScopePrototype.hasOwnProperty('$apply')) {
                   original$applyFn = rootScopePrototype.$apply;
-                  rootScopePrototype.$apply = (exp) => delayApplyExps.push(exp);
+                  rootScopePrototype.$apply = (exp: any /** TODO #???? */) => delayApplyExps.push(exp);
                 } else {
                   throw new Error("Failed to find '$apply' on '$rootScope'!");
                 }
@@ -366,7 +366,7 @@ export class UpgradeAdapter {
         (injector: angular.IInjectorService, rootScope: angular.IRootScopeService) => {
           ng1Injector = injector;
           ngZone.onMicrotaskEmpty.subscribe(
-              {next: (_) => ngZone.runOutsideAngular(() => rootScope.$evalAsync())});
+              {next: (_: any /** TODO #???? */) => ngZone.runOutsideAngular(() => rootScope.$evalAsync())});
           UpgradeNg1ComponentAdapterBuilder.resolve(this.downgradedComponents, injector)
               .then(resolve, reject);
         }
@@ -374,7 +374,7 @@ export class UpgradeAdapter {
     });
 
     // Make sure resumeBootstrap() only exists if the current bootstrap is deferred
-    var windowAngular = window['angular'];
+    var windowAngular = (window as any /** TODO #???? */)['angular'];
     windowAngular.resumeBootstrap = undefined;
 
     angular.element(element).data(controllerKey(NG2_INJECTOR), injector);
diff --git a/modules/@angular/upgrade/src/upgrade_ng1_adapter.ts b/modules/@angular/upgrade/src/upgrade_ng1_adapter.ts
index 648dbdeb39..c86174b544 100644
--- a/modules/@angular/upgrade/src/upgrade_ng1_adapter.ts
+++ b/modules/@angular/upgrade/src/upgrade_ng1_adapter.ts
@@ -41,7 +41,7 @@ export class UpgradeNg1ComponentAdapterBuilder {
   $controller: angular.IControllerService = null;
 
   constructor(public name: string) {
-    var selector = name.replace(CAMEL_CASE, (all, next: string) => '-' + next.toLowerCase());
+    var selector = name.replace(CAMEL_CASE, (all: any /** TODO #9100 */, next: string) => '-' + next.toLowerCase());
     var self = this;
     this.type =
         Directive({selector: selector, inputs: this.inputsRename, outputs: this.outputsRename})
@@ -141,7 +141,7 @@ export class UpgradeNg1ComponentAdapterBuilder {
         this.linkFn = compileHtml(html);
       } else {
         return new Promise((resolve, err) => {
-          httpBackend('GET', url, null, (status, response) => {
+          httpBackend('GET', url, null, (status: any /** TODO #9100 */, response: any /** TODO #9100 */) => {
             if (status == 200) {
               resolve(this.linkFn = compileHtml(templateCache.put(url, response)));
             } else {
@@ -154,7 +154,7 @@ export class UpgradeNg1ComponentAdapterBuilder {
       throw new Error(`Directive '${this.name}' is not a component, it is missing template.`);
     }
     return null;
-    function compileHtml(html): angular.ILinkFn {
+    function compileHtml(html: any /** TODO #9100 */): angular.ILinkFn {
       var div = document.createElement('div');
       div.innerHTML = html;
       return compile(div.childNodes);
@@ -163,7 +163,7 @@ export class UpgradeNg1ComponentAdapterBuilder {
 
   static resolve(exportedComponents: {[name: string]: UpgradeNg1ComponentAdapterBuilder},
                  injector: angular.IInjectorService): Promise<any> {
-    var promises = [];
+    var promises: any[] /** TODO #9100 */ = [];
     var compile: angular.ICompileService = injector.get(NG1_COMPILE);
     var templateCache: angular.ITemplateCacheService = injector.get(NG1_TEMPLATE_CACHE);
     var httpBackend: angular.IHttpBackendService = injector.get(NG1_HTTP_BACKEND);
@@ -205,14 +205,14 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
     }
 
     for (var i = 0; i < inputs.length; i++) {
-      this[inputs[i]] = null;
+      (this as any /** TODO #9100 */)[inputs[i]] = null;
     }
     for (var j = 0; j < outputs.length; j++) {
-      var emitter = this[outputs[j]] = new EventEmitter();
-      this.setComponentProperty(outputs[j], ((emitter) => (value) => emitter.emit(value))(emitter));
+      var emitter = (this as any /** TODO #9100 */)[outputs[j]] = new EventEmitter();
+      this.setComponentProperty(outputs[j], ((emitter: any /** TODO #9100 */) => (value: any /** TODO #9100 */) => emitter.emit(value))(emitter));
     }
     for (var k = 0; k < propOuts.length; k++) {
-      this[propOuts[k]] = new EventEmitter();
+      (this as any /** TODO #9100 */)[propOuts[k]] = new EventEmitter();
       this.checkLastValues.push(INITIAL_VALUE);
     }
 
@@ -234,7 +234,7 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
     }
 
     var childNodes: Node[] = [];
-    var childNode;
+    var childNode: any /** TODO #9100 */;
     while (childNode = this.element.firstChild) {
       this.element.removeChild(childNode);
       childNodes.push(childNode);
@@ -243,7 +243,7 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
       for (var i = 0, ii = clonedElement.length; i < ii; i++) {
         this.element.appendChild(clonedElement[i]);
       }
-    }, {parentBoundTranscludeFn: (scope, cloneAttach) => { cloneAttach(childNodes); }});
+    }, {parentBoundTranscludeFn: (scope: any /** TODO #9100 */, cloneAttach: any /** TODO #9100 */) => { cloneAttach(childNodes); }});
     if (this.destinationObj.$onInit) {
       this.destinationObj.$onInit();
     }
@@ -270,7 +270,7 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
         if (typeof value == 'number' && isNaN(value) && typeof last == 'number' && isNaN(last)) {
           // ignore because NaN != NaN
         } else {
-          var eventEmitter: EventEmitter<any> = this[this.propOuts[i]];
+          var eventEmitter: EventEmitter<any> = (this as any /** TODO #9100 */)[this.propOuts[i]];
           eventEmitter.emit(lastValues[i] = value);
         }
       }
@@ -282,7 +282,7 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
     this.destinationObj[this.propertyMap[name]] = value;
   }
 
-  private buildController(controllerType) {
+  private buildController(controllerType: any /** TODO #9100 */) {
     var locals = { $scope: this.componentScope, $element: this.$element };
     var controller:any = this.$controller(controllerType, locals, null, this.directive.controllerAs);
     this.$element.data(controllerKey(this.directive.name), controller);
@@ -319,7 +319,7 @@ class UpgradeNg1ComponentAdapter implements OnInit, OnChanges, DoCheck {
       }
       return dep;
     } else if (require instanceof Array) {
-      var deps = [];
+      var deps: any[] /** TODO #9100 */ = [];
       for (var i = 0; i < require.length; i++) {
         deps.push(this.resolveRequired($element, require[i]));
       }
diff --git a/modules/@angular/upgrade/test/upgrade_spec.ts b/modules/@angular/upgrade/test/upgrade_spec.ts
index 7df9dcded4..049c719a4a 100644
--- a/modules/@angular/upgrade/test/upgrade_spec.ts
+++ b/modules/@angular/upgrade/test/upgrade_spec.ts
@@ -8,7 +8,7 @@ export function main() {
     it('should have angular 1 loaded', () => expect(angular.version.major).toBe(1));
 
     it('should instantiate ng2 in ng1 template and project content',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var ng1Module = angular.module('ng1', []);
          var Ng2 = Component({selector: 'ng2', template: `{{ 'NG2' }}(<ng-content></ng-content>)`})
                        .Class({constructor: function() {}});
@@ -26,7 +26,7 @@ export function main() {
        }));
 
     it('should instantiate ng1 in ng2 template and project content',
-       inject([AsyncTestCompleter], (async) => {
+       inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
          var adapter: UpgradeAdapter = new UpgradeAdapter();
          var ng1Module = angular.module('ng1', []);
 
@@ -53,10 +53,10 @@ export function main() {
 
     describe('scope/component change-detection', () => {
       it('should interleave scope and component expressions',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var ng1Module = angular.module('ng1', []);
-           var log = [];
-           var l = function(value) {
+           var log: any[] /** TODO #9100 */ = [];
+           var l = function(value: any /** TODO #9100 */) {
              log.push(value);
              return value + ';';
            };
@@ -64,7 +64,7 @@ export function main() {
 
            ng1Module.directive('ng1a', () => { return {template: "{{ l('ng1a') }}"}; });
            ng1Module.directive('ng1b', () => { return {template: "{{ l('ng1b') }}"}; });
-           ng1Module.run(($rootScope) => {
+           ng1Module.run(($rootScope: any /** TODO #9100 */) => {
              $rootScope.l = l;
              $rootScope.reset = () => log.length = 0;
            });
@@ -92,11 +92,11 @@ export function main() {
     });
 
     describe('downgrade ng2 component', () => {
-      it('should bind properties, events', inject([AsyncTestCompleter], (async) => {
+      it('should bind properties, events', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter: UpgradeAdapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
-           ng1Module.run(($rootScope) => {
+           ng1Module.run(($rootScope: any /** TODO #9100 */) => {
              $rootScope.dataA = 'A';
              $rootScope.dataB = 'B';
              $rootScope.modelA = 'initModelA';
@@ -134,15 +134,15 @@ export function main() {
                        this.twoWayAEmitter = new EventEmitter();
                        this.twoWayBEmitter = new EventEmitter();
                      },
-                     ngOnChanges: function(changes) {
-                       var assert = (prop, value) => {
+                     ngOnChanges: function(changes: any /** TODO #9100 */) {
+                       var assert = (prop: any /** TODO #9100 */, value: any /** TODO #9100 */) => {
                          if (this[prop] != value) {
                            throw new Error(
                                `Expected: '${prop}' to be '${value}' but was '${this[prop]}'`);
                          }
                        };
 
-                       var assertChange = (prop, value) => {
+                       var assertChange = (prop: any /** TODO #9100 */, value: any /** TODO #9100 */) => {
                          assert(prop, value);
                          if (!changes[prop]) {
                            throw new Error(`Changes record for '${prop}' not found.`);
@@ -202,7 +202,7 @@ export function main() {
          }));
 
       it('should properly run cleanup when ng1 directive is destroyed',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter: UpgradeAdapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            var onDestroyed: EventEmitter<string> = new EventEmitter<string>();
@@ -210,7 +210,7 @@ export function main() {
            ng1Module.directive('ng1', () => {
              return {
                template: '<div ng-if="!destroyIt"><ng2></ng2></div>',
-               controller: function($rootScope, $timeout) {
+               controller: function($rootScope: any /** TODO #9100 */, $timeout: any /** TODO #9100 */) {
                  $timeout(function() { $rootScope.destroyIt = true; });
                }
              };
@@ -232,13 +232,13 @@ export function main() {
 
 
       it('should fallback to the root ng2.injector when compiled outside the dom',
-        inject([AsyncTestCompleter], (async) => {
+        inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
           var adapter: UpgradeAdapter = new UpgradeAdapter();
           var ng1Module = angular.module('ng1', []);
 
-          ng1Module.directive('ng1', ['$compile', ($compile) => {
+          ng1Module.directive('ng1', ['$compile', ($compile: any /** TODO #9100 */) => {
             return {
-              link: function($scope, $element, $attrs) {
+              link: function($scope: any /** TODO #9100 */, $element: any /** TODO #9100 */, $attrs: any /** TODO #9100 */) {
                 var compiled = $compile("<ng2></ng2>");
                 var template = compiled($scope);
                 $element.append(template);
@@ -263,7 +263,7 @@ export function main() {
     });
 
     describe('upgrade ng1 component', () => {
-      it('should bind properties, events', inject([AsyncTestCompleter], (async) => {
+      it('should bind properties, events', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -271,8 +271,8 @@ export function main() {
              return {
                template: 'Hello {{fullName}}; A: {{dataA}}; B: {{dataB}}; | ',
                scope: {fullName: '@', modelA: '=dataA', modelB: '=dataB', event: '&'},
-               link: function(scope) {
-                 scope.$watch('dataB', (v) => {
+               link: function(scope: any /** TODO #9100 */) {
+                 scope.$watch('dataB', (v: any /** TODO #9100 */) => {
                    if (v == 'Savkin') {
                      scope.dataB = 'SAVKIN';
                      scope.event('WORKS');
@@ -318,7 +318,7 @@ export function main() {
                });
          }));
 
-      it('should bind properties, events in controller when bindToController is not used', inject([AsyncTestCompleter], (async) => {
+      it('should bind properties, events in controller when bindToController is not used', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
         var adapter = new UpgradeAdapter();
         var ng1Module = angular.module('ng1', []);
 
@@ -327,7 +327,7 @@ export function main() {
             restrict: 'E',
             template: '{{someText}} - Length: {{data.length}}',
             scope: { data: "="},
-            controller: function($scope) {
+            controller: function($scope: any /** TODO #9100 */) {
               $scope.someText = "ng1 - Data: " + $scope.data;
             }
           };
@@ -362,7 +362,7 @@ export function main() {
           });
       }));
 
-      it('should bind properties, events in link function', inject([AsyncTestCompleter], (async) => {
+      it('should bind properties, events in link function', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
         var adapter = new UpgradeAdapter();
         var ng1Module = angular.module('ng1', []);
 
@@ -371,7 +371,7 @@ export function main() {
             restrict: 'E',
             template: '{{someText}} - Length: {{data.length}}',
             scope: { data: "=" },
-            link: function($scope) {
+            link: function($scope: any /** TODO #9100 */) {
               $scope.someText = "ng1 - Data: " + $scope.data;
             }
           };
@@ -407,11 +407,11 @@ export function main() {
       }));
 
       it('should support templateUrl fetched from $httpBackend',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            ng1Module.value('$httpBackend',
-                           (method, url, post, cbFn) => { cbFn(200, `${method}:${url}`); });
+                           (method: any /** TODO #9100 */, url: any /** TODO #9100 */, post: any /** TODO #9100 */, cbFn: any /** TODO #9100 */) => { cbFn(200, `${method}:${url}`); });
 
            var ng1 = function() { return {templateUrl: 'url.html'}; };
            ng1Module.directive('ng1', ng1);
@@ -431,11 +431,11 @@ export function main() {
          }));
 
       it('should support templateUrl as a function',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            ng1Module.value('$httpBackend',
-                           (method, url, post, cbFn) => { cbFn(200, `${method}:${url}`); });
+                           (method: any /** TODO #9100 */, url: any /** TODO #9100 */, post: any /** TODO #9100 */, cbFn: any /** TODO #9100 */) => { cbFn(200, `${method}:${url}`); });
 
            var ng1 = function() { return {templateUrl(){ return 'url.html' }}; };
            ng1Module.directive('ng1', ng1);
@@ -454,7 +454,7 @@ export function main() {
                });
          }));
 
-      it('should support empty template', inject([AsyncTestCompleter], (async) => {
+      it('should support empty template', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -475,7 +475,7 @@ export function main() {
                });
          }));
 
-      it('should support template as a function', inject([AsyncTestCompleter], (async) => {
+      it('should support template as a function', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -497,10 +497,10 @@ export function main() {
          }));
 
       it('should support templateUrl fetched from $templateCache',
-         inject([AsyncTestCompleter], (async) => {
+         inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
-           ng1Module.run(($templateCache) => $templateCache.put('url.html', 'WORKS'));
+           ng1Module.run(($templateCache: any /** TODO #9100 */) => $templateCache.put('url.html', 'WORKS'));
 
            var ng1 = function() { return {templateUrl: 'url.html'}; };
            ng1Module.directive('ng1', ng1);
@@ -519,7 +519,7 @@ export function main() {
                });
          }));
 
-      it('should support controller with controllerAs', inject([AsyncTestCompleter], (async) => {
+      it('should support controller with controllerAs', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -530,7 +530,7 @@ export function main() {
                    '{{ctl.scope}}; {{ctl.isClass}}; {{ctl.hasElement}}; {{ctl.isPublished()}}',
                controllerAs: 'ctl',
                controller: Class({
-                 constructor: function($scope, $element) {
+                 constructor: function($scope: any /** TODO #9100 */, $element: any /** TODO #9100 */) {
                    (<any>this).verifyIAmAClass();
                    this.scope = $scope.$parent.$parent == $scope.$root ? 'scope' : 'wrong-scope';
                    this.hasElement = $element[0].nodeName;
@@ -560,7 +560,7 @@ export function main() {
                });
          }));
 
-      it('should support bindToController', inject([AsyncTestCompleter], (async) => {
+      it('should support bindToController', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -589,7 +589,7 @@ export function main() {
                });
          }));
 
-      it('should support bindToController with bindings', inject([AsyncTestCompleter], (async) => {
+      it('should support bindToController with bindings', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -618,11 +618,11 @@ export function main() {
                });
          }));
 
-      it('should support single require in linking fn', inject([AsyncTestCompleter], (async) => {
+      it('should support single require in linking fn', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
-           var ng1 = function($rootScope) {
+           var ng1 = function($rootScope: any /** TODO #9100 */) {
              return {
                scope: {title: '@'},
                bindToController: true,
@@ -630,7 +630,7 @@ export function main() {
                require: 'ng1',
                controllerAs: 'ctrl',
                controller: Class({constructor: function() { this.status = 'WORKS'; }}),
-               link: function(scope, element, attrs, linkController) {
+               link: function(scope: any /** TODO #9100 */, element: any /** TODO #9100 */, attrs: any /** TODO #9100 */, linkController: any /** TODO #9100 */) {
                  expect(scope.$root).toEqual($rootScope);
                  expect(element[0].nodeName).toEqual('NG1');
                  expect(linkController.status).toEqual('WORKS');
@@ -654,7 +654,7 @@ export function main() {
                });
          }));
 
-      it('should support array require in linking fn', inject([AsyncTestCompleter], (async) => {
+      it('should support array require in linking fn', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -669,7 +669,7 @@ export function main() {
                require: ['ng1', '^parent', '?^^notFound'],
                controllerAs: 'ctrl',
                controller: Class({constructor: function() { this.status = 'WORKS'; }}),
-               link: function(scope, element, attrs, linkControllers) {
+               link: function(scope: any /** TODO #9100 */, element: any /** TODO #9100 */, attrs: any /** TODO #9100 */, linkControllers: any /** TODO #9100 */) {
                  expect(linkControllers[0].status).toEqual('WORKS');
                  expect(linkControllers[1].parent).toEqual('PARENT');
                  expect(linkControllers[2]).toBe(undefined);
@@ -695,7 +695,7 @@ export function main() {
                });
          }));
 
-      it('should call $onInit of components', inject([AsyncTestCompleter], (async) => {
+      it('should call $onInit of components', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            var valueToFind = '$onInit';
@@ -724,7 +724,7 @@ export function main() {
                });
          }));
 
-      it('should bind input properties (<) of components', inject([AsyncTestCompleter], (async) => {
+      it('should bind input properties (<) of components', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -755,7 +755,7 @@ export function main() {
                });
          }));
 
-       it('should support ng2 > ng1 > ng2', inject([AsyncTestCompleter], (async) => {
+       it('should support ng2 > ng1 > ng2', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
 
@@ -798,7 +798,7 @@ export function main() {
     describe('injection', () => {
       function SomeToken() {}
 
-      it('should export ng2 instance to ng1', inject([AsyncTestCompleter], (async) => {
+      it('should export ng2 instance to ng1', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var module = angular.module('myExample', []);
            adapter.addProvider({provide: SomeToken, useValue: 'correct_value'});
@@ -811,7 +811,7 @@ export function main() {
                });
          }));
 
-      it('should export ng1 instance to ng2', inject([AsyncTestCompleter], (async) => {
+      it('should export ng1 instance to ng2', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var module = angular.module('myExample', []);
            module.value('testValue', 'secreteToken');
@@ -830,7 +830,7 @@ export function main() {
     });
 
     describe('testability', () => {
-      it('should handle deferred bootstrap', inject([AsyncTestCompleter], (async) => {
+      it('should handle deferred bootstrap', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter: UpgradeAdapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            var bootstrapResumed: boolean = false;
@@ -851,7 +851,7 @@ export function main() {
            }, 100);
          }));
 
-      it('should wait for ng2 testability', inject([AsyncTestCompleter], (async) => {
+      it('should wait for ng2 testability', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter: UpgradeAdapter = new UpgradeAdapter();
            var ng1Module = angular.module('ng1', []);
            var element = html("<div></div>");
@@ -876,7 +876,7 @@ export function main() {
     });
 
     describe('examples', () => {
-      it('should verify UpgradeAdapter example', inject([AsyncTestCompleter], (async) => {
+      it('should verify UpgradeAdapter example', inject([AsyncTestCompleter], (async: any /** TODO #9100 */) => {
            var adapter = new UpgradeAdapter();
            var module = angular.module('myExample', []);
 
diff --git a/modules/empty.ts b/modules/empty.ts
index 89ec055603..3ed7df017e 100644
--- a/modules/empty.ts
+++ b/modules/empty.ts
@@ -1,4 +1,4 @@
 // This file intentionally left blank. It is used to load nothing in some cases.
 // Such as parse5/index is redirected here instead of loading into browser.
 
-export var __empty__;
+export var __empty__: any /** TODO #9100 */;
diff --git a/modules/playground/e2e_test/alt_routing/routing_spec.ts b/modules/playground/e2e_test/alt_routing/routing_spec.ts
index e3b343eb9d..a0f4234484 100644
--- a/modules/playground/e2e_test/alt_routing/routing_spec.ts
+++ b/modules/playground/e2e_test/alt_routing/routing_spec.ts
@@ -1,6 +1,6 @@
 import {verifyNoBrowserErrors} from '@angular/platform-browser/testing_e2e';
 
-function waitForElement(selector) {
+function waitForElement(selector: any /** TODO #9100 */) {
   var EC = (<any>protractor).ExpectedConditions;
   // Waits for the element with id 'abc' to be present on the dom.
   browser.wait(EC.presenceOf($(selector)), 20000);
diff --git a/modules/playground/e2e_test/hash_routing/hash_location_spec.ts b/modules/playground/e2e_test/hash_routing/hash_location_spec.ts
index 1ab50246a1..fc45c0f510 100644
--- a/modules/playground/e2e_test/hash_routing/hash_location_spec.ts
+++ b/modules/playground/e2e_test/hash_routing/hash_location_spec.ts
@@ -1,6 +1,6 @@
 import {verifyNoBrowserErrors} from '@angular/platform-browser/testing_e2e';
 
-function waitForElement(selector) {
+function waitForElement(selector: any /** TODO #9100 */) {
   var EC = (<any>protractor).ExpectedConditions;
   // Waits for the element with id 'abc' to be present on the dom.
   browser.wait(EC.presenceOf($(selector)), 20000);
diff --git a/modules/playground/e2e_test/hello_world/hello_world_spec.ts b/modules/playground/e2e_test/hello_world/hello_world_spec.ts
index 6a948ebb10..beba624dd1 100644
--- a/modules/playground/e2e_test/hello_world/hello_world_spec.ts
+++ b/modules/playground/e2e_test/hello_world/hello_world_spec.ts
@@ -23,12 +23,12 @@ describe('hello world', function() {
 
 });
 
-function getComponentText(selector, innerSelector) {
+function getComponentText(selector: any /** TODO #9100 */, innerSelector: any /** TODO #9100 */) {
   return browser.executeScript('return document.querySelector("' + selector + '").querySelector("' +
                                innerSelector + '").textContent');
 }
 
-function clickComponentButton(selector, innerSelector) {
+function clickComponentButton(selector: any /** TODO #9100 */, innerSelector: any /** TODO #9100 */) {
   return browser.executeScript('return document.querySelector("' + selector + '").querySelector("' +
                                innerSelector + '").click()');
 }
diff --git a/modules/playground/e2e_test/http/http_spec.ts b/modules/playground/e2e_test/http/http_spec.ts
index 8959ee8013..a4b07cec15 100644
--- a/modules/playground/e2e_test/http/http_spec.ts
+++ b/modules/playground/e2e_test/http/http_spec.ts
@@ -14,7 +14,7 @@ describe('http', function() {
   });
 });
 
-function getComponentText(selector, innerSelector) {
+function getComponentText(selector: any /** TODO #9100 */, innerSelector: any /** TODO #9100 */) {
   return browser.executeScript('return document.querySelector("' + selector + '").querySelector("' +
                                innerSelector + '").textContent.trim()');
 }
diff --git a/modules/playground/e2e_test/jsonp/jsonp_spec.ts b/modules/playground/e2e_test/jsonp/jsonp_spec.ts
index a8f0b5af5b..9c0bf4fdf3 100644
--- a/modules/playground/e2e_test/jsonp/jsonp_spec.ts
+++ b/modules/playground/e2e_test/jsonp/jsonp_spec.ts
@@ -14,7 +14,7 @@ describe('jsonp', function() {
   });
 });
 
-function getComponentText(selector, innerSelector) {
+function getComponentText(selector: any /** TODO #9100 */, innerSelector: any /** TODO #9100 */) {
   return browser.executeScript('return document.querySelector("' + selector + '").querySelector("' +
                                innerSelector + '").textContent.trim()');
 }
diff --git a/modules/playground/e2e_test/relative_assets/assets_spec.ts b/modules/playground/e2e_test/relative_assets/assets_spec.ts
index ff7b5a574f..b8d0804bf8 100644
--- a/modules/playground/e2e_test/relative_assets/assets_spec.ts
+++ b/modules/playground/e2e_test/relative_assets/assets_spec.ts
@@ -1,6 +1,6 @@
 import {verifyNoBrowserErrors} from '@angular/platform-browser/testing_e2e';
 
-function waitForElement(selector) {
+function waitForElement(selector: any /** TODO #9100 */) {
   var EC = (<any>protractor).ExpectedConditions;
   // Waits for the element with id 'abc' to be present on the dom.
   browser.wait(EC.presenceOf($(selector)), 20000);
@@ -24,7 +24,7 @@ describe('relative assets relative-app', () => {
 
     waitForElement('my-cmp .inner-container');
     var elem = element(by.css('my-cmp .inner-container'));
-    var width = browser.executeScript(function(e) {
+    var width = browser.executeScript(function(e: any /** TODO #9100 */) {
       return parseInt(window.getComputedStyle(e).width);
     }, elem.getWebElement());
 
diff --git a/modules/playground/e2e_test/routing/routing_spec.ts b/modules/playground/e2e_test/routing/routing_spec.ts
index 1aa5425fbb..2c9d697119 100644
--- a/modules/playground/e2e_test/routing/routing_spec.ts
+++ b/modules/playground/e2e_test/routing/routing_spec.ts
@@ -1,6 +1,6 @@
 import {verifyNoBrowserErrors} from '@angular/platform-browser/testing_e2e';
 
-function waitForElement(selector) {
+function waitForElement(selector: any /** TODO #9100 */) {
   var EC = (<any>protractor).ExpectedConditions;
   // Waits for the element with id 'abc' to be present on the dom.
   browser.wait(EC.presenceOf($(selector)), 20000);
diff --git a/modules/playground/e2e_test/sourcemap/sourcemap_spec.ts b/modules/playground/e2e_test/sourcemap/sourcemap_spec.ts
index b33741fae3..480167990e 100644
--- a/modules/playground/e2e_test/sourcemap/sourcemap_spec.ts
+++ b/modules/playground/e2e_test/sourcemap/sourcemap_spec.ts
@@ -15,8 +15,8 @@ describe('sourcemaps', function() {
     // so that the browser logs can be read out!
     browser.executeScript('1+1');
     browser.manage().logs().get('browser').then(function(logs) {
-      var errorLine = null;
-      var errorColumn = null;
+      var errorLine: any /** TODO #9100 */ = null;
+      var errorColumn: any /** TODO #9100 */ = null;
       logs.forEach(function(log) {
         var match = /\.createError\s+\(.+:(\d+):(\d+)/m.exec(log.message);
         if (match) {
diff --git a/modules/playground/e2e_test/web_workers/router/router_spec.ts b/modules/playground/e2e_test/web_workers/router/router_spec.ts
index 1e277f5f5d..87bf7dc169 100644
--- a/modules/playground/e2e_test/web_workers/router/router_spec.ts
+++ b/modules/playground/e2e_test/web_workers/router/router_spec.ts
@@ -64,7 +64,7 @@ describe("WebWorker Router", () => {
     }, 5000);
   }
 
-  function waitForUrl(regex): void {
+  function waitForUrl(regex: any /** TODO #9100 */): void {
     browser.wait(() => {
       let deferred = protractor.promise.defer();
       browser.getCurrentUrl().then(
diff --git a/modules/playground/src/alt_routing/app/inbox-app.ts b/modules/playground/src/alt_routing/app/inbox-app.ts
index 08f37791a2..b7bc191c64 100644
--- a/modules/playground/src/alt_routing/app/inbox-app.ts
+++ b/modules/playground/src/alt_routing/app/inbox-app.ts
@@ -53,8 +53,8 @@ class InboxRecord {
     this.subject = record['subject'];
     this.content = record['content'];
     this.email = record['email'];
-    this.firstName = record['first-name'];
-    this.lastName = record['last-name'];
+    this.firstName = (record as any /** TODO #9100 */)['first-name'];
+    this.lastName = (record as any /** TODO #9100 */)['last-name'];
     this.date = record['date'];
     this.draft = record['draft'] == true;
   }
@@ -79,7 +79,7 @@ class DbService {
                                    data.filter(record => !isPresent(record['draft'])));
   }
 
-  email(id): Promise<any> {
+  email(id: any /** TODO #9100 */): Promise<any> {
     return PromiseWrapper.then(this.getData(), (data: any[]) => {
       for (var i = 0; i < data.length; i++) {
         var entry = data[i];
diff --git a/modules/playground/src/animate/app/animate-app.ts b/modules/playground/src/animate/app/animate-app.ts
index 604de904c4..8b3b0939dd 100644
--- a/modules/playground/src/animate/app/animate-app.ts
+++ b/modules/playground/src/animate/app/animate-app.ts
@@ -60,8 +60,8 @@ import {
   ]
 })
 export class AnimateApp {
-  public items = [];
-  public _state;
+  public items: any[] /** TODO #9100 */ = [];
+  public _state: any /** TODO #9100 */;
 
   public bgStatus = 'focus';
 
diff --git a/modules/playground/src/async/index.ts b/modules/playground/src/async/index.ts
index e5e19f3b89..c44894c0c2 100644
--- a/modules/playground/src/async/index.ts
+++ b/modules/playground/src/async/index.ts
@@ -33,9 +33,9 @@ class AsyncApplication {
   val2: number = 0;
   val3: number = 0;
   val4: number = 0;
-  timeoutId = null;
-  multiTimeoutId = null;
-  intervalId = null;
+  timeoutId: any /** TODO #9100 */ = null;
+  multiTimeoutId: any /** TODO #9100 */ = null;
+  intervalId: any /** TODO #9100 */ = null;
 
   increment(): void { this.val1++; };
 
@@ -51,7 +51,7 @@ class AsyncApplication {
     this.cancelMultiDelayedIncrements();
 
     var self = this;
-    function helper(_i) {
+    function helper(_i: any /** TODO #9100 */) {
       if (_i <= 0) {
         self.multiTimeoutId = null;
         return;
diff --git a/modules/playground/src/bootstrap.ts b/modules/playground/src/bootstrap.ts
index 03460b3b4f..d07f3bce14 100644
--- a/modules/playground/src/bootstrap.ts
+++ b/modules/playground/src/bootstrap.ts
@@ -1,7 +1,7 @@
 declare var System: any;
 
 
-(function(global) {
+(function(global: any /** TODO #9100 */) {
 
   writeScriptTag('/all/playground/vendor/es6-shim.js');
   writeScriptTag('/all/playground/vendor/zone.js');
@@ -59,11 +59,11 @@ declare var System: any;
 
 
     // BOOTSTRAP the app!
-    System.import('index').then(function(m) { m.main(); }, console.error.bind(console));
+    System.import('index').then(function(m: any /** TODO #9100 */) { m.main(); }, console.error.bind(console));
   }
 
 
-  function writeScriptTag(scriptUrl, onload?) {
+  function writeScriptTag(scriptUrl: any /** TODO #9100 */, onload?: any /** TODO #9100 */) {
     document.write(`<script src="${scriptUrl}" onload="${onload}"></script>`);
   }
 }(window));
diff --git a/modules/playground/src/gestures/index.ts b/modules/playground/src/gestures/index.ts
index 5c8daf3029..686108f953 100644
--- a/modules/playground/src/gestures/index.ts
+++ b/modules/playground/src/gestures/index.ts
@@ -7,11 +7,11 @@ class GesturesCmp {
   pinchScale: number = 1;
   rotateAngle: number = 0;
 
-  onSwipe(event): void { this.swipeDirection = event.deltaX > 0 ? 'right' : 'left'; }
+  onSwipe(event: any /** TODO #9100 */): void { this.swipeDirection = event.deltaX > 0 ? 'right' : 'left'; }
 
-  onPinch(event): void { this.pinchScale = event.scale; }
+  onPinch(event: any /** TODO #9100 */): void { this.pinchScale = event.scale; }
 
-  onRotate(event): void { this.rotateAngle = event.rotation; }
+  onRotate(event: any /** TODO #9100 */): void { this.rotateAngle = event.rotation; }
 }
 
 export function main() {
diff --git a/modules/playground/src/key_events/index.ts b/modules/playground/src/key_events/index.ts
index ebd15f6f54..4c44075dfe 100644
--- a/modules/playground/src/key_events/index.ts
+++ b/modules/playground/src/key_events/index.ts
@@ -18,12 +18,12 @@ class KeyEventsApp {
   lastKey: string = '(none)';
   shiftEnter: boolean = false;
 
-  onKeyDown(event): void {
+  onKeyDown(event: any /** TODO #9100 */): void {
     this.lastKey = KeyEventsPlugin.getEventFullKey(event);
     event.preventDefault();
   }
 
-  onShiftEnter(event): void {
+  onShiftEnter(event: any /** TODO #9100 */): void {
     this.shiftEnter = true;
     event.preventDefault();
   }
diff --git a/modules/playground/src/model_driven_forms/index.ts b/modules/playground/src/model_driven_forms/index.ts
index 42ca195bfb..5a4f36dff6 100644
--- a/modules/playground/src/model_driven_forms/index.ts
+++ b/modules/playground/src/model_driven_forms/index.ts
@@ -48,7 +48,7 @@ function creditCardValidator(c: AbstractControl): {[key: string]: boolean} {
   directives: [NgIf]
 })
 class ShowError {
-  formDir;
+  formDir: any /** TODO #9100 */;
   controlPath: string;
   errorTypes: string[];
 
@@ -69,7 +69,7 @@ class ShowError {
 
   _errorMessage(code: string): string {
     var config = {'required': 'is required', 'invalidCreditCard': 'is invalid credit card number'};
-    return config[code];
+    return (config as any /** TODO #9100 */)[code];
   }
 }
 
@@ -135,7 +135,7 @@ class ShowError {
   directives: [FORM_DIRECTIVES, NgFor, ShowError]
 })
 class ModelDrivenForms {
-  form;
+  form: any /** TODO #9100 */;
   countries = ['US', 'Canada'];
 
   constructor(fb: FormBuilder) {
diff --git a/modules/playground/src/routing/app/inbox-app.ts b/modules/playground/src/routing/app/inbox-app.ts
index 0637fa8bd9..3c941937b8 100644
--- a/modules/playground/src/routing/app/inbox-app.ts
+++ b/modules/playground/src/routing/app/inbox-app.ts
@@ -49,8 +49,8 @@ class InboxRecord {
     this.subject = record['subject'];
     this.content = record['content'];
     this.email = record['email'];
-    this.firstName = record['first-name'];
-    this.lastName = record['last-name'];
+    this.firstName = (record as any /** TODO #9100 */)['first-name'];
+    this.lastName = (record as any /** TODO #9100 */)['last-name'];
     this.date = record['date'];
     this.draft = record['draft'] == true;
   }
@@ -75,7 +75,7 @@ class DbService {
                                    data.filter(record => !isPresent(record['draft'])));
   }
 
-  email(id): Promise<any> {
+  email(id: any /** TODO #9100 */): Promise<any> {
     return PromiseWrapper.then(this.getData(), (data: any[]) => {
       for (var i = 0; i < data.length; i++) {
         var entry = data[i];
diff --git a/modules/playground/src/template_driven_forms/index.ts b/modules/playground/src/template_driven_forms/index.ts
index c94be6d187..9cf29c378d 100644
--- a/modules/playground/src/template_driven_forms/index.ts
+++ b/modules/playground/src/template_driven_forms/index.ts
@@ -31,7 +31,7 @@ class CheckoutModel {
 /**
  * Custom validator.
  */
-function creditCardValidator(c): {[key: string]: boolean} {
+function creditCardValidator(c: any /** TODO #9100 */): {[key: string]: boolean} {
   if (isPresent(c.value) && RegExpWrapper.test(/^\d{16}$/g, c.value)) {
     return null;
   } else {
@@ -73,7 +73,7 @@ class CreditCardValidator {
   directives: [NgIf]
 })
 class ShowError {
-  formDir;
+  formDir: any /** TODO #9100 */;
   controlPath: string;
   errorTypes: string[];
 
@@ -94,7 +94,7 @@ class ShowError {
 
   _errorMessage(code: string): string {
     var config = {'required': 'is required', 'invalidCreditCard': 'is invalid credit card number'};
-    return config[code];
+    return (config as any /** TODO #9100 */)[code];
   }
 }
 
diff --git a/modules/playground/src/todo/index.ts b/modules/playground/src/todo/index.ts
index 88335d4878..5e9d81314d 100644
--- a/modules/playground/src/todo/index.ts
+++ b/modules/playground/src/todo/index.ts
@@ -14,14 +14,14 @@ class TodoApp {
 
   constructor(public todoStore: Store<Todo>, public factory: TodoFactory) {}
 
-  enterTodo(inputElement): void {
+  enterTodo(inputElement: any /** TODO #9100 */): void {
     this.addTodo(inputElement.value);
     inputElement.value = '';
   }
 
   editTodo(todo: Todo): void { this.todoEdit = todo; }
 
-  doneEditing($event, todo: Todo): void {
+  doneEditing($event: any /** TODO #9100 */, todo: Todo): void {
     var which = $event.which;
     var target = $event.target;
     if (which === 13) {
@@ -39,7 +39,7 @@ class TodoApp {
 
   deleteMe(todo: Todo): void { this.todoStore.remove(todo); }
 
-  toggleAll($event): void {
+  toggleAll($event: any /** TODO #9100 */): void {
     var isComplete = $event.target.checked;
     this.todoStore.list.forEach((todo: Todo) => { todo.completed = isComplete; });
   }
diff --git a/modules/playground/src/upgrade/index.ts b/modules/playground/src/upgrade/index.ts
index 098453cd3a..69ab973225 100644
--- a/modules/playground/src/upgrade/index.ts
+++ b/modules/playground/src/upgrade/index.ts
@@ -22,7 +22,7 @@ var adapter: UpgradeAdapter = new UpgradeAdapter();
 
 var ng1module = angular.module('myExample', []);
 
-ng1module.controller('Index', function($scope) { $scope.name = 'World'; });
+ng1module.controller('Index', function($scope: any /** TODO #9100 */) { $scope.name = 'World'; });
 
 ng1module.directive('user', function() {
   return {
diff --git a/modules/playground/src/web_workers/images/index_common.ts b/modules/playground/src/web_workers/images/index_common.ts
index 0a11eef5bc..e17bfdff16 100644
--- a/modules/playground/src/web_workers/images/index_common.ts
+++ b/modules/playground/src/web_workers/images/index_common.ts
@@ -7,12 +7,12 @@ import {FileReader, Uint8ArrayWrapper} from './file_api';
 
 @Component({selector: 'image-demo', viewProviders: [BitmapService], templateUrl: 'image_demo.html'})
 export class ImageDemo {
-  images = [];
+  images: any[] /** TODO #9100 */ = [];
   fileInput: String;
 
   constructor(private _bitmapService: BitmapService) {}
 
-  uploadFiles(files) {
+  uploadFiles(files: any /** TODO #9100 */) {
     for (var i = 0; i < files.length; i++) {
       var reader = new FileReader();
       reader.addEventListener("load", this.handleReaderLoad(reader));
diff --git a/modules/playground/src/web_workers/images/services/bitmap.ts b/modules/playground/src/web_workers/images/services/bitmap.ts
index 9272d0f8b0..ee60d8c227 100644
--- a/modules/playground/src/web_workers/images/services/bitmap.ts
+++ b/modules/playground/src/web_workers/images/services/bitmap.ts
@@ -1,6 +1,6 @@
 /// <reference path="../bitmap.d.ts" /> /// <reference path="../b64.d.ts" />
 import {Injectable} from '@angular/core';
-declare var base64js;
+declare var base64js: any /** TODO #9100 */;
 
 // Temporary fix for Typescript issue #4220 (https://github.com/Microsoft/TypeScript/issues/4220)
 // var _ImageData: (width: number, height: number) => void = <any>postMessage;
@@ -151,7 +151,7 @@ export class BitmapService {
   // Based on example from
   // http://www.worldwidewhat.net/2012/07/how-to-draw-bitmaps-using-javascript/
   private _getLittleEndianHex(value: number): string {
-    var result = [];
+    var result: any[] /** TODO #9100 */ = [];
 
     for (var bytes = 4; bytes > 0; bytes--) {
       result.push(String.fromCharCode(value & 255));
diff --git a/modules/playground/src/web_workers/input/index_common.ts b/modules/playground/src/web_workers/input/index_common.ts
index ded9907bd6..51fb3bc866 100644
--- a/modules/playground/src/web_workers/input/index_common.ts
+++ b/modules/playground/src/web_workers/input/index_common.ts
@@ -18,7 +18,7 @@ export class InputCmp {
   inputVal = "";
   textareaVal = "";
 
-  inputChanged(e) { this.inputVal = e.target.value; }
+  inputChanged(e: any /** TODO #9100 */) { this.inputVal = e.target.value; }
 
-  textAreaChanged(e) { this.textareaVal = e.target.value; }
+  textAreaChanged(e: any /** TODO #9100 */) { this.textareaVal = e.target.value; }
 }
diff --git a/modules/playground/src/web_workers/kitchen_sink/index_common.ts b/modules/playground/src/web_workers/kitchen_sink/index_common.ts
index 79d8901278..b04c219ef7 100644
--- a/modules/playground/src/web_workers/kitchen_sink/index_common.ts
+++ b/modules/playground/src/web_workers/kitchen_sink/index_common.ts
@@ -52,5 +52,5 @@ export class HelloCmp {
 
   changeGreeting(): void { this.greeting = 'howdy'; }
 
-  onKeyDown(event): void { this.lastKey = StringWrapper.fromCharCode(event.keyCode); }
+  onKeyDown(event: any /** TODO #9100 */): void { this.lastKey = StringWrapper.fromCharCode(event.keyCode); }
 }
diff --git a/modules/playground/src/web_workers/todo/index_common.ts b/modules/playground/src/web_workers/todo/index_common.ts
index 3e27e348df..184e90fa8f 100644
--- a/modules/playground/src/web_workers/todo/index_common.ts
+++ b/modules/playground/src/web_workers/todo/index_common.ts
@@ -22,7 +22,7 @@ export class TodoApp {
     this.inputValue = "";
   }
 
-  doneEditing($event, todo: Todo): void {
+  doneEditing($event: any /** TODO #9100 */, todo: Todo): void {
     var which = $event.keyCode;
     if (which === 13) {
       todo.title = todo.editTitle;
@@ -56,7 +56,7 @@ export class TodoApp {
 
   deleteMe(todo: Todo): void { this.todoStore.remove(todo); }
 
-  toggleAll($event): void {
+  toggleAll($event: any /** TODO #9100 */): void {
     this.isComplete = !this.isComplete;
     this.todoStore.list.forEach((todo: Todo) => { todo.completed = this.isComplete; });
   }
diff --git a/modules/tsconfig.json b/modules/tsconfig.json
index d9957851cf..47536dca30 100644
--- a/modules/tsconfig.json
+++ b/modules/tsconfig.json
@@ -10,6 +10,7 @@
     "module": "commonjs",
     "moduleResolution": "node",
     "outDir": "../dist/all/",
+    "noImplicitAny": true,
     "paths": {
       "selenium-webdriver": ["../node_modules/@types/selenium-webdriver/index.d.ts"],
       "rxjs/*": ["../node_modules/rxjs/*"],