From 604c8bbad54ffbcec1d6a5e407821adda8a74a19 Mon Sep 17 00:00:00 2001
From: Jeff Cross <middlefloor@gmail.com>
Date: Mon, 16 Nov 2015 17:04:36 -0800
Subject: [PATCH] refactor(lifecycle): prefix lifecycle methods with "ng"

BREAKING CHANGE:
Previously, components that would implement lifecycle interfaces would include methods
like "onChanges" or "afterViewInit." Given that components were at risk of using such
names without realizing that Angular would call the methods at different points of
the component lifecycle. This change adds an "ng" prefix to all lifecycle hook methods,
far reducing the risk of an accidental name collision.

To fix, just rename these methods:
 * onInit
 * onDestroy
 * doCheck
 * onChanges
 * afterContentInit
 * afterContentChecked
 * afterViewInit
 * afterViewChecked
 * _Router Hooks_
 * onActivate
 * onReuse
 * onDeactivate
 * canReuse
 * canDeactivate

To:
 * ngOnInit,
 * ngOnDestroy,
 * ngDoCheck,
 * ngOnChanges,
 * ngAfterContentInit,
 * ngAfterContentChecked,
 * ngAfterViewInit,
 * ngAfterViewChecked
 * _Router Hooks_
 * routerOnActivate
 * routerOnReuse
 * routerOnDeactivate
 * routerCanReuse
 * routerCanDeactivate

The names of lifecycle interfaces and enums have not changed, though interfaces
have been updated to reflect the new method names.

Closes #5036
---
 modules/angular1_router/src/ng_outlet.ts      |  24 +-
 .../test/integration/animation_spec.js        |   2 +-
 .../test/integration/lifecycle_hook_spec.js   |  50 ++--
 .../test/integration/navigation_spec.js       |   2 +-
 .../docs/cheatsheet/lifecycle hooks.md        |  22 +-
 modules/angular2/docs/cheatsheet/routing.md   |  18 +-
 .../can_deactivate/can_deactivate_example.ts  |   4 +-
 .../router/ts/can_deactivate/index.html       |   2 +-
 .../ts/on_activate/on_activate_example.ts     |   6 +-
 .../router/ts/on_activate/on_activate_spec.ts |   6 +-
 .../ts/on_deactivate/on_deactivate_example.ts |   4 +-
 .../examples/router/ts/reuse/reuse_example.ts |   4 +-
 .../src/common/directives/ng_class.ts         |   4 +-
 .../angular2/src/common/directives/ng_for.ts  |   2 +-
 .../src/common/directives/ng_style.ts         |   2 +-
 .../forms/directives/ng_control_group.ts      |   4 +-
 .../forms/directives/ng_control_name.ts       |   4 +-
 .../forms/directives/ng_form_control.ts       |   2 +-
 .../common/forms/directives/ng_form_model.ts  |   2 +-
 .../src/common/forms/directives/ng_model.ts   |   2 +-
 .../change_detection_jit_generator.ts         |   6 +-
 .../change_detection/codegen_logic_util.ts    |   8 +-
 .../dynamic_change_detector.ts                |  14 +-
 .../linker/directive_lifecycle_reflector.ts   |  16 +-
 .../src/core/linker/element_injector.ts       |  30 +--
 .../angular2/src/core/linker/interfaces.ts    |  64 ++---
 modules/angular2/src/core/linker/view.ts      |   4 +-
 .../angular2/src/core/linker/view_manager.ts  |   4 +-
 modules/angular2/src/core/metadata.ts         |  16 +-
 modules/angular2/src/core/metadata/di.ts      |  16 +-
 .../angular2/src/core/metadata/directives.ts  |   8 +-
 modules/angular2/src/router/interfaces.ts     |  61 +++--
 .../src/router/lifecycle_annotations.ts       |  10 +-
 .../src/router/lifecycle_annotations_impl.ts  |  16 +-
 .../src/router/route_lifecycle_reflector.dart |  10 +-
 modules/angular2/src/router/router.ts         |  16 +-
 modules/angular2/src/router/router_outlet.ts  |  40 ++--
 .../src/upgrade/downgrade_ng2_adapter.ts      |   5 +-
 .../src/upgrade/upgrade_ng1_adapter.ts        |   8 +-
 .../test/common/forms/directives_spec.ts      |  14 +-
 .../angular2/test/common/forms/model_spec.ts  |   8 +-
 .../test/compiler/runtime_metadata_spec.ts    |  16 +-
 .../change_detection/change_detector_spec.ts  | 200 ++++++++--------
 .../core/change_detection/coalesce_spec.ts    |   4 +-
 .../directive_lifecycle_integration_spec.ts   |  25 +-
 .../core/linker/directive_lifecycle_spec.dart |  48 ++--
 .../core/linker/directive_lifecycle_spec.ts   |  48 ++--
 .../linker/dynamic_component_loader_spec.ts   |   2 +-
 .../test/core/linker/element_injector_spec.ts |  20 +-
 .../core/linker/integration_dart_spec.dart    |   4 +-
 .../core/linker/query_integration_spec.ts     |  12 +-
 .../test/platform/browser/bootstrap_spec.ts   |   2 +-
 modules/angular2/test/public_api_spec.ts      |  22 +-
 .../test/router/integration/bootstrap_spec.ts |   2 +-
 .../router/integration/lifecycle_hook_spec.ts | 222 +++++++++---------
 modules/angular2/test/router/router_spec.ts   |   4 +-
 modules/angular2/test/upgrade/upgrade_spec.ts |   8 +-
 .../src/components/button/button.ts           |   2 +-
 .../src/components/grid_list/grid_list.ts     |   6 +-
 .../src/components/input/input.ts             |   2 +-
 .../progress-linear/progress_linear.ts        |   2 +-
 .../src/components/radio/radio_button.ts      |   4 +-
 .../change_detector_codegen.dart              |   6 +-
 63 files changed, 618 insertions(+), 583 deletions(-)

diff --git a/modules/angular1_router/src/ng_outlet.ts b/modules/angular1_router/src/ng_outlet.ts
index 4e2774fbae..6184f7655a 100644
--- a/modules/angular1_router/src/ng_outlet.ts
+++ b/modules/angular1_router/src/ng_outlet.ts
@@ -106,21 +106,21 @@ function ngOutletDirective($animate, $q: ng.IQService, $router) {
         let next = $q.when(true);
         let previousInstruction = this.currentInstruction;
         this.currentInstruction = instruction;
-        if (this.currentController && this.currentController.$onReuse) {
+        if (this.currentController && this.currentController.$routerOnReuse) {
           next = $q.when(
-              this.currentController.$onReuse(this.currentInstruction, previousInstruction));
+              this.currentController.$routerOnReuse(this.currentInstruction, previousInstruction));
         }
 
         return next;
       }
 
-      canReuse(nextInstruction) {
+      routerCanReuse(nextInstruction) {
         let result;
         if (!this.currentInstruction ||
             this.currentInstruction.componentType !== nextInstruction.componentType) {
           result = false;
-        } else if (this.currentController && this.currentController.$canReuse) {
-          result = this.currentController.$canReuse(nextInstruction, this.currentInstruction);
+        } else if (this.currentController && this.currentController.$routerCanReuse) {
+          result = this.currentController.$routerCanReuse(nextInstruction, this.currentInstruction);
         } else {
           result = nextInstruction === this.currentInstruction ||
                    angular.equals(nextInstruction.params, this.currentInstruction.params);
@@ -128,18 +128,18 @@ function ngOutletDirective($animate, $q: ng.IQService, $router) {
         return $q.when(result);
       }
 
-      canDeactivate(instruction) {
-        if (this.currentController && this.currentController.$canDeactivate) {
+      routerCanDeactivate(instruction) {
+        if (this.currentController && this.currentController.$routerCanDeactivate) {
           return $q.when(
-              this.currentController.$canDeactivate(instruction, this.currentInstruction));
+              this.currentController.$routerCanDeactivate(instruction, this.currentInstruction));
         }
         return $q.when(true);
       }
 
       deactivate(instruction) {
-        if (this.currentController && this.currentController.$onDeactivate) {
+        if (this.currentController && this.currentController.$routerOnDeactivate) {
           return $q.when(
-              this.currentController.$onDeactivate(instruction, this.currentInstruction));
+              this.currentController.$routerOnDeactivate(instruction, this.currentInstruction));
         }
         return $q.when();
       }
@@ -172,8 +172,8 @@ function ngOutletDirective($animate, $q: ng.IQService, $router) {
         // by debug mode
         this.currentController = this.currentElement.children().eq(0).controller(componentName);
 
-        if (this.currentController && this.currentController.$onActivate) {
-          return this.currentController.$onActivate(instruction, previousInstruction);
+        if (this.currentController && this.currentController.$routerOnActivate) {
+          return this.currentController.$routerOnActivate(instruction, previousInstruction);
         }
         return $q.when();
       }
diff --git a/modules/angular1_router/test/integration/animation_spec.js b/modules/angular1_router/test/integration/animation_spec.js
index 1ad02c6fb9..513ca33e6c 100644
--- a/modules/angular1_router/test/integration/animation_spec.js
+++ b/modules/angular1_router/test/integration/animation_spec.js
@@ -70,7 +70,7 @@ describe('ngOutlet animations', function () {
   function registerComponent(name, options) {
     var controller = options.controller || function () {};
 
-    ['$onActivate', '$onDeactivate', '$onReuse', '$canReuse', '$canDeactivate'].forEach(function (hookName) {
+    ['$routerOnActivate', '$routerOnDeactivate', '$routerOnReuse', '$routerCanReuse', '$routerCanDeactivate'].forEach(function (hookName) {
       if (options[hookName]) {
         controller.prototype[hookName] = options[hookName];
       }
diff --git a/modules/angular1_router/test/integration/lifecycle_hook_spec.js b/modules/angular1_router/test/integration/lifecycle_hook_spec.js
index 4ac9f6414e..56a2ac04f6 100644
--- a/modules/angular1_router/test/integration/lifecycle_hook_spec.js
+++ b/modules/angular1_router/test/integration/lifecycle_hook_spec.js
@@ -35,7 +35,7 @@ describe('Navigation lifecycle', function () {
     var spy = jasmine.createSpy('activate');
     registerComponent('activateCmp', {
       template: '<p>hello</p>',
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -53,7 +53,7 @@ describe('Navigation lifecycle', function () {
   it('should pass instruction into the activate hook of a controller', function () {
     var spy = jasmine.createSpy('activate');
     registerComponent('userCmp', {
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -72,7 +72,7 @@ describe('Navigation lifecycle', function () {
     var spy = jasmine.createSpy('activate');
     var activate = registerComponent('activateCmp', {
       template: 'hi',
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -113,7 +113,7 @@ describe('Navigation lifecycle', function () {
   it('should run the deactivate hook of controllers', function () {
     var spy = jasmine.createSpy('deactivate');
     registerComponent('deactivateCmp', {
-      $onDeactivate: spy
+      $routerOnDeactivate: spy
     });
 
     $router.config([
@@ -133,7 +133,7 @@ describe('Navigation lifecycle', function () {
   it('should pass instructions into the deactivate hook of controllers', function () {
     var spy = jasmine.createSpy('deactivate');
     registerComponent('deactivateCmp', {
-      $onDeactivate: spy
+      $routerOnDeactivate: spy
     });
 
     $router.config([
@@ -155,13 +155,13 @@ describe('Navigation lifecycle', function () {
     var log = [];
 
     registerComponent('activateCmp', {
-      $onActivate: function () {
+      $routerOnActivate: function () {
         log.push('activate');
       }
     });
 
     registerComponent('deactivateCmp', {
-      $onDeactivate: function () {
+      $routerOnDeactivate: function () {
         log.push('deactivate');
       }
     });
@@ -180,7 +180,7 @@ describe('Navigation lifecycle', function () {
     expect(log).toEqual(['deactivate', 'activate']);
   });
 
-  it('should reuse a component when the canReuse hook returns true', function () {
+  it('should reuse a component when the routerCanReuse hook returns true', function () {
     var log = [];
     var cmpInstanceCount = 0;
 
@@ -195,10 +195,10 @@ describe('Navigation lifecycle', function () {
         {path: '/b', component: 'twoCmp'}
       ],
       controller: ReuseCmp,
-      $canReuse: function () {
+      $routerCanReuse: function () {
         return true;
       },
-      $onReuse: function (next, prev) {
+      $routerOnReuse: function (next, prev) {
         log.push('reuse: ' + prev.urlPath + ' -> ' + next.urlPath);
       }
     });
@@ -223,7 +223,7 @@ describe('Navigation lifecycle', function () {
   });
 
 
-  it('should not reuse a component when the canReuse hook returns false', function () {
+  it('should not reuse a component when the routerCanReuse hook returns false', function () {
     var log = [];
     var cmpInstanceCount = 0;
 
@@ -237,10 +237,10 @@ describe('Navigation lifecycle', function () {
         {path: '/b', component: 'twoCmp'}
       ],
       controller: NeverReuseCmp,
-      $canReuse: function () {
+      $routerCanReuse: function () {
         return false;
       },
-      $onReuse: function (next, prev) {
+      $routerOnReuse: function (next, prev) {
         log.push('reuse: ' + prev.urlPath + ' -> ' + next.urlPath);
       }
     });
@@ -271,7 +271,7 @@ describe('Navigation lifecycle', function () {
     var spy = jasmine.createSpy('activate');
     registerComponent('activateCmp', {
       $canActivate: canActivateSpy,
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -293,7 +293,7 @@ describe('Navigation lifecycle', function () {
     registerComponent('activateCmp', {
       template: 'hi',
       $canActivate: canActivateSpy,
-      $onActivate: activateSpy
+      $routerOnActivate: activateSpy
     });
 
     $router.config([
@@ -317,7 +317,7 @@ describe('Navigation lifecycle', function () {
       $canActivate: function () {
         return $q.when(true);
       },
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -356,10 +356,10 @@ describe('Navigation lifecycle', function () {
   }));
 
 
-  it('should not navigate when canDeactivate returns false', function () {
+  it('should not navigate when routerCanDeactivate returns false', function () {
     registerComponent('activateCmp', {
       template: 'hi',
-      $canDeactivate: function () {
+      $routerCanDeactivate: function () {
         return false;
       }
     });
@@ -380,10 +380,10 @@ describe('Navigation lifecycle', function () {
   });
 
 
-  it('should navigate when canDeactivate returns true', function () {
+  it('should navigate when routerCanDeactivate returns true', function () {
     registerComponent('activateCmp', {
       template: 'hi',
-      $canDeactivate: function () {
+      $routerCanDeactivate: function () {
         return true;
       }
     });
@@ -411,7 +411,7 @@ describe('Navigation lifecycle', function () {
       $canActivate: function () {
         return true;
       },
-      $onActivate: spy
+      $routerOnActivate: spy
     });
 
     $router.config([
@@ -427,10 +427,10 @@ describe('Navigation lifecycle', function () {
   });
 
 
-  it('should pass instructions into the canDeactivate hook of controllers', function () {
-    var spy = jasmine.createSpy('canDeactivate').and.returnValue(true);
+  it('should pass instructions into the routerCanDeactivate hook of controllers', function () {
+    var spy = jasmine.createSpy('routerCanDeactivate').and.returnValue(true);
     registerComponent('deactivateCmp', {
-      $canDeactivate: spy
+      $routerCanDeactivate: spy
     });
 
     $router.config([
@@ -451,7 +451,7 @@ describe('Navigation lifecycle', function () {
   function registerComponent(name, options) {
     var controller = options.controller || function () {};
 
-    ['$onActivate', '$onDeactivate', '$onReuse', '$canReuse', '$canDeactivate'].forEach(function (hookName) {
+    ['$routerOnActivate', '$routerOnDeactivate', '$routerOnReuse', '$routerCanReuse', '$routerCanDeactivate'].forEach(function (hookName) {
       if (options[hookName]) {
         controller.prototype[hookName] = options[hookName];
       }
diff --git a/modules/angular1_router/test/integration/navigation_spec.js b/modules/angular1_router/test/integration/navigation_spec.js
index 76b9490bab..3d230c4b12 100644
--- a/modules/angular1_router/test/integration/navigation_spec.js
+++ b/modules/angular1_router/test/integration/navigation_spec.js
@@ -230,7 +230,7 @@ describe('navigation', function () {
   function registerComponent(name, options) {
     var controller = options.controller || function () {};
 
-    ['$onActivate', '$onDeactivate', '$onReuse', '$canReuse', '$canDeactivate'].forEach(function (hookName) {
+    ['$routerOnActivate', '$routerOnDeactivate', '$routerOnReuse', '$routerCanReuse', '$routerCanDeactivate'].forEach(function (hookName) {
       if (options[hookName]) {
         controller.prototype[hookName] = options[hookName];
       }
diff --git a/modules/angular2/docs/cheatsheet/lifecycle hooks.md b/modules/angular2/docs/cheatsheet/lifecycle hooks.md
index e592dbebc1..efbc7700fb 100644
--- a/modules/angular2/docs/cheatsheet/lifecycle hooks.md	
+++ b/modules/angular2/docs/cheatsheet/lifecycle hooks.md	
@@ -10,40 +10,40 @@ The class constructor is called before any other lifecycle hook. Use it to injec
 
 
 @cheatsheetItem
-`onChanges(changeRecord) { ... }`|`onChanges(changeRecord)`
+`ngOnChanges(changeRecord) { ... }`|`ngOnChanges(changeRecord)`
 Called after every change to input properties and before processing content or child views.
 
 
 @cheatsheetItem
-`onInit() { ... }`|`onInit()`
-Called after the constructor, initializing input properties, and the first call to onChanges.
+`ngOnInit() { ... }`|`ngOnInit()`
+Called after the constructor, initializing input properties, and the first call to ngOnChanges.
 
 
 @cheatsheetItem
-`doCheck() { ... }`|`doCheck()`
+`ngDoCheck() { ... }`|`ngDoCheck()`
 Called every time that the input properties of a component or a directive are checked. Use it to extend change detection by performing a custom check.
 
 
 @cheatsheetItem
-`afterContentInit() { ... }`|`afterContentInit()`
-Called after onInit when the component's or directive's content has been initialized.
+`ngAfterContentInit() { ... }`|`ngAfterContentInit()`
+Called after ngOnInit when the component's or directive's content has been initialized.
 
 
 @cheatsheetItem
-`afterContentChecked() { ... }`|`afterContentChecked()`
+`ngAfterContentChecked() { ... }`|`ngAfterContentChecked()`
 Called after every check of the component's or directive's content.
 
 
 @cheatsheetItem
-`afterViewInit() { ... }`|`afterViewInit()`
-Called after afterContentInit when the component's view has been initialized. Applies to components only.
+`ngAfterViewInit() { ... }`|`ngAfterViewInit()`
+Called after ngAfterContentInit when the component's view has been initialized. Applies to components only.
 
 
 @cheatsheetItem
-`afterViewChecked() { ... }`|`afterViewChecked()`
+`ngAfterViewChecked() { ... }`|`ngAfterViewChecked()`
 Called after every check of the component's view. Applies to components only.
 
 
 @cheatsheetItem
-`onDestroy() { ... }`|`onDestroy()`
+`ngOnDestroy() { ... }`|`ngOnDestroy()`
 Called once, before the instance is destroyed.
\ No newline at end of file
diff --git a/modules/angular2/docs/cheatsheet/routing.md b/modules/angular2/docs/cheatsheet/routing.md
index 823c0eb4fe..75e8d03875 100644
--- a/modules/angular2/docs/cheatsheet/routing.md
+++ b/modules/angular2/docs/cheatsheet/routing.md
@@ -31,25 +31,25 @@ A component decorator defining a function that the router should call first to d
 
 
 @cheatsheetItem
-`onActivate(nextInstruction, prevInstruction) { ... }`|`onActivate`
-After navigating to a component, the router calls component's onActivate method (if defined).
+`routerOnActivate(nextInstruction, prevInstruction) { ... }`|`routerOnActivate`
+After navigating to a component, the router calls component's routerOnActivate method (if defined).
 
 
 @cheatsheetItem
-`canReuse(nextInstruction, prevInstruction) { ... }`|`canReuse`
-The router calls a component's canReuse method (if defined) to determine whether to reuse the instance or destroy it and create a new instance. Should return a boolean or a promise.
+`routerCanReuse(nextInstruction, prevInstruction) { ... }`|`routerCanReuse`
+The router calls a component's routerCanReuse method (if defined) to determine whether to reuse the instance or destroy it and create a new instance. Should return a boolean or a promise.
 
 
 @cheatsheetItem
-`onReuse(nextInstruction, prevInstruction) { ... }`|`onReuse`
-The router calls the component's onReuse method (if defined) when it re-uses a component instance.
+`routerOnReuse(nextInstruction, prevInstruction) { ... }`|`routerOnReuse`
+The router calls the component's routerOnReuse method (if defined) when it re-uses a component instance.
 
 
 @cheatsheetItem
-`canDeactivate(nextInstruction, prevInstruction) { ... }`|`canDeactivate`
-The router calls the canDeactivate methods (if defined) of every component that would be removed after a navigation. The navigation proceeds if and only if all such methods return true or a promise that is resolved.
+`routerCanDeactivate(nextInstruction, prevInstruction) { ... }`|`routerCanDeactivate`
+The router calls the routerCanDeactivate methods (if defined) of every component that would be removed after a navigation. The navigation proceeds if and only if all such methods return true or a promise that is resolved.
 
 
 @cheatsheetItem
-`onDeactivate(nextInstruction, prevInstruction) { ... }`|`onDeactivate`
+`routerOnDeactivate(nextInstruction, prevInstruction) { ... }`|`routerOnDeactivate`
 Called before the directive is removed as the result of a route change. May return a promise that pauses removing the directive until the promise resolves.
\ No newline at end of file
diff --git a/modules/angular2/examples/router/ts/can_deactivate/can_deactivate_example.ts b/modules/angular2/examples/router/ts/can_deactivate/can_deactivate_example.ts
index bf42714492..f7bbbdf19e 100644
--- a/modules/angular2/examples/router/ts/can_deactivate/can_deactivate_example.ts
+++ b/modules/angular2/examples/router/ts/can_deactivate/can_deactivate_example.ts
@@ -8,7 +8,7 @@ import {
   APP_BASE_HREF
 } from 'angular2/router';
 
-// #docregion canDeactivate
+// #docregion routerCanDeactivate
 @Component({
   selector: 'note-cmp',
   template: `
@@ -22,7 +22,7 @@ class NoteCmp implements CanDeactivate {
 
   constructor(params: RouteParams) { this.id = params.get('id'); }
 
-  canDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
     return confirm('Are you sure you want to leave?');
   }
 }
diff --git a/modules/angular2/examples/router/ts/can_deactivate/index.html b/modules/angular2/examples/router/ts/can_deactivate/index.html
index a19917b671..05a7324d38 100644
--- a/modules/angular2/examples/router/ts/can_deactivate/index.html
+++ b/modules/angular2/examples/router/ts/can_deactivate/index.html
@@ -1,7 +1,7 @@
 <!doctype html>
 <html>
 <head>
-  <title>Routing canDeactivate Lifecycle Example</title>
+  <title>Routing routerCanDeactivate Lifecycle Example</title>
   <base href="/">
 
   <script src="http://cdn.rawgit.com/google/traceur-compiler/90da568c7aa8e53ea362db1fc211fbb4f65b5e94/bin/traceur-runtime.js"></script>
diff --git a/modules/angular2/examples/router/ts/on_activate/on_activate_example.ts b/modules/angular2/examples/router/ts/on_activate/on_activate_example.ts
index 557c9e8255..921b84ed0c 100644
--- a/modules/angular2/examples/router/ts/on_activate/on_activate_example.ts
+++ b/modules/angular2/examples/router/ts/on_activate/on_activate_example.ts
@@ -8,12 +8,12 @@ import {
 } from 'angular2/router';
 
 
-// #docregion onActivate
-@Component({selector: 'my-cmp', template: `<div>onActivate: {{log}}</div>`})
+// #docregion routerOnActivate
+@Component({selector: 'my-cmp', template: `<div>routerOnActivate: {{log}}</div>`})
 class MyCmp implements OnActivate {
   log: string = '';
 
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
     this.log = `Finished navigating from "${prev ? prev.urlPath : 'null'}" to "${next.urlPath}"`;
   }
 }
diff --git a/modules/angular2/examples/router/ts/on_activate/on_activate_spec.ts b/modules/angular2/examples/router/ts/on_activate/on_activate_spec.ts
index 3e15a69952..d6e57e6fba 100644
--- a/modules/angular2/examples/router/ts/on_activate/on_activate_spec.ts
+++ b/modules/angular2/examples/router/ts/on_activate/on_activate_spec.ts
@@ -17,18 +17,18 @@ describe('on activate example app', function() {
     waitForElement('my-cmp');
 
     expect(element(by.css('my-cmp')).getText())
-        .toContain('onActivate: Finished navigating from "null" to ""');
+        .toContain('routerOnActivate: Finished navigating from "null" to ""');
 
     element(by.css('#param-link')).click();
     waitForElement('my-cmp');
 
     expect(element(by.css('my-cmp')).getText())
-        .toContain('onActivate: Finished navigating from "" to "1"');
+        .toContain('routerOnActivate: Finished navigating from "" to "1"');
 
     browser.navigate().back();
     waitForElement('my-cmp');
 
     expect(element(by.css('my-cmp')).getText())
-        .toContain('onActivate: Finished navigating from "1" to ""');
+        .toContain('routerOnActivate: Finished navigating from "1" to ""');
   });
 });
diff --git a/modules/angular2/examples/router/ts/on_deactivate/on_deactivate_example.ts b/modules/angular2/examples/router/ts/on_deactivate/on_deactivate_example.ts
index 34152ebf5f..b2fe3f7131 100644
--- a/modules/angular2/examples/router/ts/on_deactivate/on_deactivate_example.ts
+++ b/modules/angular2/examples/router/ts/on_deactivate/on_deactivate_example.ts
@@ -16,12 +16,12 @@ class LogService {
 }
 
 
-// #docregion onDeactivate
+// #docregion routerOnDeactivate
 @Component({selector: 'my-cmp', template: `<div>hello</div>`})
 class MyCmp implements OnDeactivate {
   constructor(private logService: LogService) {}
 
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
     this.logService.addLog(
         `Navigating from "${prev ? prev.urlPath : 'null'}" to "${next.urlPath}"`);
   }
diff --git a/modules/angular2/examples/router/ts/reuse/reuse_example.ts b/modules/angular2/examples/router/ts/reuse/reuse_example.ts
index 8b0bc05452..637a753b76 100644
--- a/modules/angular2/examples/router/ts/reuse/reuse_example.ts
+++ b/modules/angular2/examples/router/ts/reuse/reuse_example.ts
@@ -24,9 +24,9 @@ class MyCmp implements CanReuse,
   name: string;
   constructor(params: RouteParams) { this.name = params.get('name') || 'NOBODY'; }
 
-  canReuse(next: ComponentInstruction, prev: ComponentInstruction) { return true; }
+  routerCanReuse(next: ComponentInstruction, prev: ComponentInstruction) { return true; }
 
-  onReuse(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnReuse(next: ComponentInstruction, prev: ComponentInstruction) {
     this.name = next.params['name'];
   }
 }
diff --git a/modules/angular2/src/common/directives/ng_class.ts b/modules/angular2/src/common/directives/ng_class.ts
index 373fad193d..bf7ca61781 100644
--- a/modules/angular2/src/common/directives/ng_class.ts
+++ b/modules/angular2/src/common/directives/ng_class.ts
@@ -108,7 +108,7 @@ export class NgClass implements DoCheck, OnDestroy {
     }
   }
 
-  doCheck(): void {
+  ngDoCheck(): void {
     if (isPresent(this._differ)) {
       var changes = this._differ.diff(this._rawClass);
       if (isPresent(changes)) {
@@ -121,7 +121,7 @@ export class NgClass implements DoCheck, OnDestroy {
     }
   }
 
-  onDestroy(): void { this._cleanupClasses(this._rawClass); }
+  ngOnDestroy(): void { this._cleanupClasses(this._rawClass); }
 
   private _cleanupClasses(rawClassVal): void {
     this._applyClasses(rawClassVal, true);
diff --git a/modules/angular2/src/common/directives/ng_for.ts b/modules/angular2/src/common/directives/ng_for.ts
index 068b8e25d0..6b37e87858 100644
--- a/modules/angular2/src/common/directives/ng_for.ts
+++ b/modules/angular2/src/common/directives/ng_for.ts
@@ -81,7 +81,7 @@ export class NgFor implements DoCheck {
     }
   }
 
-  doCheck() {
+  ngDoCheck() {
     if (isPresent(this._differ)) {
       var changes = this._differ.diff(this._ngForOf);
       if (isPresent(changes)) this._applyChanges(changes);
diff --git a/modules/angular2/src/common/directives/ng_style.ts b/modules/angular2/src/common/directives/ng_style.ts
index bdc2e3f0ec..9e53e312b3 100644
--- a/modules/angular2/src/common/directives/ng_style.ts
+++ b/modules/angular2/src/common/directives/ng_style.ts
@@ -75,7 +75,7 @@ export class NgStyle implements DoCheck {
     }
   }
 
-  doCheck() {
+  ngDoCheck() {
     if (isPresent(this._differ)) {
       var changes = this._differ.diff(this._rawStyle);
       if (isPresent(changes)) {
diff --git a/modules/angular2/src/common/forms/directives/ng_control_group.ts b/modules/angular2/src/common/forms/directives/ng_control_group.ts
index 310b8cd167..f99aa42144 100644
--- a/modules/angular2/src/common/forms/directives/ng_control_group.ts
+++ b/modules/angular2/src/common/forms/directives/ng_control_group.ts
@@ -87,9 +87,9 @@ export class NgControlGroup extends ControlContainer implements OnInit,
     this._parent = parent;
   }
 
-  onInit(): void { this.formDirective.addControlGroup(this); }
+  ngOnInit(): void { this.formDirective.addControlGroup(this); }
 
-  onDestroy(): void { this.formDirective.removeControlGroup(this); }
+  ngOnDestroy(): void { this.formDirective.removeControlGroup(this); }
 
   /**
    * Get the {@link ControlGroup} backing this binding.
diff --git a/modules/angular2/src/common/forms/directives/ng_control_name.ts b/modules/angular2/src/common/forms/directives/ng_control_name.ts
index 31df287534..c43eda0b04 100644
--- a/modules/angular2/src/common/forms/directives/ng_control_name.ts
+++ b/modules/angular2/src/common/forms/directives/ng_control_name.ts
@@ -114,7 +114,7 @@ export class NgControlName extends NgControl implements OnChanges,
     this.valueAccessor = selectValueAccessor(this, valueAccessors);
   }
 
-  onChanges(changes: {[key: string]: SimpleChange}) {
+  ngOnChanges(changes: {[key: string]: SimpleChange}) {
     if (!this._added) {
       this.formDirective.addControl(this);
       this._added = true;
@@ -125,7 +125,7 @@ export class NgControlName extends NgControl implements OnChanges,
     }
   }
 
-  onDestroy(): void { this.formDirective.removeControl(this); }
+  ngOnDestroy(): void { this.formDirective.removeControl(this); }
 
   viewToModelUpdate(newValue: any): void {
     this.viewModel = newValue;
diff --git a/modules/angular2/src/common/forms/directives/ng_form_control.ts b/modules/angular2/src/common/forms/directives/ng_form_control.ts
index 75f0f6c3d6..4ee46cd156 100644
--- a/modules/angular2/src/common/forms/directives/ng_form_control.ts
+++ b/modules/angular2/src/common/forms/directives/ng_form_control.ts
@@ -97,7 +97,7 @@ export class NgFormControl extends NgControl implements OnChanges {
     this.valueAccessor = selectValueAccessor(this, valueAccessors);
   }
 
-  onChanges(changes: {[key: string]: SimpleChange}): void {
+  ngOnChanges(changes: {[key: string]: SimpleChange}): void {
     if (this._isControlChanged(changes)) {
       setUpControl(this.form, this);
       this.form.updateValueAndValidity({emitEvent: false});
diff --git a/modules/angular2/src/common/forms/directives/ng_form_model.ts b/modules/angular2/src/common/forms/directives/ng_form_model.ts
index a766f8a323..5e28486ae4 100644
--- a/modules/angular2/src/common/forms/directives/ng_form_model.ts
+++ b/modules/angular2/src/common/forms/directives/ng_form_model.ts
@@ -113,7 +113,7 @@ export class NgFormModel extends ControlContainer implements Form,
     super();
   }
 
-  onChanges(changes: {[key: string]: SimpleChange}): void {
+  ngOnChanges(changes: {[key: string]: SimpleChange}): void {
     if (StringMapWrapper.contains(changes, "form")) {
       var sync = composeValidators(this._validators);
       this.form.validator = Validators.compose([this.form.validator, sync]);
diff --git a/modules/angular2/src/common/forms/directives/ng_model.ts b/modules/angular2/src/common/forms/directives/ng_model.ts
index 6119cc23a4..cffcb79087 100644
--- a/modules/angular2/src/common/forms/directives/ng_model.ts
+++ b/modules/angular2/src/common/forms/directives/ng_model.ts
@@ -71,7 +71,7 @@ export class NgModel extends NgControl implements OnChanges {
     this.valueAccessor = selectValueAccessor(this, valueAccessors);
   }
 
-  onChanges(changes: {[key: string]: SimpleChange}) {
+  ngOnChanges(changes: {[key: string]: SimpleChange}) {
     if (!this._added) {
       setUpControl(this._control, this);
       this._control.updateValueAndValidity({emitEvent: false});
diff --git a/modules/angular2/src/core/change_detection/change_detection_jit_generator.ts b/modules/angular2/src/core/change_detection/change_detection_jit_generator.ts
index 44ecca9c3d..14c9cafc7e 100644
--- a/modules/angular2/src/core/change_detection/change_detection_jit_generator.ts
+++ b/modules/angular2/src/core/change_detection/change_detection_jit_generator.ts
@@ -473,19 +473,19 @@ export class ChangeDetectorJITGenerator {
   /** @internal */
   _genOnCheck(r: ProtoRecord): string {
     var br = r.bindingRecord;
-    return `if (!throwOnChange) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.doCheck();`;
+    return `if (!throwOnChange) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.ngDoCheck();`;
   }
 
   /** @internal */
   _genOnInit(r: ProtoRecord): string {
     var br = r.bindingRecord;
-    return `if (!throwOnChange && ${this._names.getStateName()} === ${this.changeDetectorStateVarName}.NeverChecked) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.onInit();`;
+    return `if (!throwOnChange && ${this._names.getStateName()} === ${this.changeDetectorStateVarName}.NeverChecked) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.ngOnInit();`;
   }
 
   /** @internal */
   _genOnChange(r: ProtoRecord): string {
     var br = r.bindingRecord;
-    return `if (!throwOnChange && ${CHANGES_LOCAL}) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.onChanges(${CHANGES_LOCAL});`;
+    return `if (!throwOnChange && ${CHANGES_LOCAL}) ${this._names.getDirectiveName(br.directiveRecord.directiveIndex)}.ngOnChanges(${CHANGES_LOCAL});`;
   }
 
   /** @internal */
diff --git a/modules/angular2/src/core/change_detection/codegen_logic_util.ts b/modules/angular2/src/core/change_detection/codegen_logic_util.ts
index b837f70c85..2c2e2ab741 100644
--- a/modules/angular2/src/core/change_detection/codegen_logic_util.ts
+++ b/modules/angular2/src/core/change_detection/codegen_logic_util.ts
@@ -189,11 +189,11 @@ export class CodegenLogicUtil {
       var dir = directiveRecords[i];
       if (dir.callAfterContentInit) {
         res.push(
-            `if(${this._names.getStateName()} ${eq} ${this._changeDetectorStateName}.NeverChecked) ${this._names.getDirectiveName(dir.directiveIndex)}.afterContentInit();`);
+            `if(${this._names.getStateName()} ${eq} ${this._changeDetectorStateName}.NeverChecked) ${this._names.getDirectiveName(dir.directiveIndex)}.ngAfterContentInit();`);
       }
 
       if (dir.callAfterContentChecked) {
-        res.push(`${this._names.getDirectiveName(dir.directiveIndex)}.afterContentChecked();`);
+        res.push(`${this._names.getDirectiveName(dir.directiveIndex)}.ngAfterContentChecked();`);
       }
     }
     return res;
@@ -207,11 +207,11 @@ export class CodegenLogicUtil {
       var dir = directiveRecords[i];
       if (dir.callAfterViewInit) {
         res.push(
-            `if(${this._names.getStateName()} ${eq} ${this._changeDetectorStateName}.NeverChecked) ${this._names.getDirectiveName(dir.directiveIndex)}.afterViewInit();`);
+            `if(${this._names.getStateName()} ${eq} ${this._changeDetectorStateName}.NeverChecked) ${this._names.getDirectiveName(dir.directiveIndex)}.ngAfterViewInit();`);
       }
 
       if (dir.callAfterViewChecked) {
-        res.push(`${this._names.getDirectiveName(dir.directiveIndex)}.afterViewChecked();`);
+        res.push(`${this._names.getDirectiveName(dir.directiveIndex)}.ngAfterViewChecked();`);
       }
     }
     return res;
diff --git a/modules/angular2/src/core/change_detection/dynamic_change_detector.ts b/modules/angular2/src/core/change_detection/dynamic_change_detector.ts
index f66d8af520..344b71ff5a 100644
--- a/modules/angular2/src/core/change_detection/dynamic_change_detector.ts
+++ b/modules/angular2/src/core/change_detection/dynamic_change_detector.ts
@@ -155,12 +155,12 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
 
       if (proto.isLifeCycleRecord()) {
         if (proto.name === "DoCheck" && !throwOnChange) {
-          this._getDirectiveFor(directiveRecord.directiveIndex).doCheck();
+          this._getDirectiveFor(directiveRecord.directiveIndex).ngDoCheck();
         } else if (proto.name === "OnInit" && !throwOnChange &&
                    this.state == ChangeDetectorState.NeverChecked) {
-          this._getDirectiveFor(directiveRecord.directiveIndex).onInit();
+          this._getDirectiveFor(directiveRecord.directiveIndex).ngOnInit();
         } else if (proto.name === "OnChanges" && isPresent(changes) && !throwOnChange) {
-          this._getDirectiveFor(directiveRecord.directiveIndex).onChanges(changes);
+          this._getDirectiveFor(directiveRecord.directiveIndex).ngOnChanges(changes);
         }
       } else if (proto.isSkipRecord()) {
         protoIdx += this._computeSkipLength(protoIdx, proto, this.values);
@@ -195,11 +195,11 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
     for (var i = dirs.length - 1; i >= 0; --i) {
       var dir = dirs[i];
       if (dir.callAfterContentInit && this.state == ChangeDetectorState.NeverChecked) {
-        this._getDirectiveFor(dir.directiveIndex).afterContentInit();
+        this._getDirectiveFor(dir.directiveIndex).ngAfterContentInit();
       }
 
       if (dir.callAfterContentChecked) {
-        this._getDirectiveFor(dir.directiveIndex).afterContentChecked();
+        this._getDirectiveFor(dir.directiveIndex).ngAfterContentChecked();
       }
     }
   }
@@ -209,10 +209,10 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
     for (var i = dirs.length - 1; i >= 0; --i) {
       var dir = dirs[i];
       if (dir.callAfterViewInit && this.state == ChangeDetectorState.NeverChecked) {
-        this._getDirectiveFor(dir.directiveIndex).afterViewInit();
+        this._getDirectiveFor(dir.directiveIndex).ngAfterViewInit();
       }
       if (dir.callAfterViewChecked) {
-        this._getDirectiveFor(dir.directiveIndex).afterViewChecked();
+        this._getDirectiveFor(dir.directiveIndex).ngAfterViewChecked();
       }
     }
   }
diff --git a/modules/angular2/src/core/linker/directive_lifecycle_reflector.ts b/modules/angular2/src/core/linker/directive_lifecycle_reflector.ts
index b72ca4a3f2..9733940a8d 100644
--- a/modules/angular2/src/core/linker/directive_lifecycle_reflector.ts
+++ b/modules/angular2/src/core/linker/directive_lifecycle_reflector.ts
@@ -8,21 +8,21 @@ export function hasLifecycleHook(lcInterface: LifecycleHooks, token): boolean {
 
   switch (lcInterface) {
     case LifecycleHooks.AfterContentInit:
-      return !!proto.afterContentInit;
+      return !!proto.ngAfterContentInit;
     case LifecycleHooks.AfterContentChecked:
-      return !!proto.afterContentChecked;
+      return !!proto.ngAfterContentChecked;
     case LifecycleHooks.AfterViewInit:
-      return !!proto.afterViewInit;
+      return !!proto.ngAfterViewInit;
     case LifecycleHooks.AfterViewChecked:
-      return !!proto.afterViewChecked;
+      return !!proto.ngAfterViewChecked;
     case LifecycleHooks.OnChanges:
-      return !!proto.onChanges;
+      return !!proto.ngOnChanges;
     case LifecycleHooks.DoCheck:
-      return !!proto.doCheck;
+      return !!proto.ngDoCheck;
     case LifecycleHooks.OnDestroy:
-      return !!proto.onDestroy;
+      return !!proto.ngOnDestroy;
     case LifecycleHooks.OnInit:
-      return !!proto.onInit;
+      return !!proto.ngOnInit;
     default:
       return false;
   }
diff --git a/modules/angular2/src/core/linker/element_injector.ts b/modules/angular2/src/core/linker/element_injector.ts
index 13c210c49b..fa45081b1f 100644
--- a/modules/angular2/src/core/linker/element_injector.ts
+++ b/modules/angular2/src/core/linker/element_injector.ts
@@ -49,6 +49,7 @@ import {QueryList} from './query_list';
 import {reflector} from 'angular2/src/core/reflection/reflection';
 import {SetterFn} from 'angular2/src/core/reflection/types';
 import {EventConfig} from 'angular2/src/core/linker/event_config';
+import {AfterViewChecked} from 'angular2/src/core/linker/interfaces';
 import {PipeProvider} from 'angular2/src/core/pipes/pipe_provider';
 
 import {LifecycleHooks} from './interfaces';
@@ -326,7 +327,8 @@ class _Context {
   constructor(public element: any, public componentElement: any, public injector: any) {}
 }
 
-export class ElementInjector extends TreeNode<ElementInjector> implements DependencyProvider {
+export class ElementInjector extends TreeNode<ElementInjector> implements DependencyProvider,
+    AfterViewChecked {
   private _host: ElementInjector;
   private _preBuiltObjects: PreBuiltObjects = null;
   private _queryStrategy: _QueryStrategy;
@@ -564,9 +566,9 @@ export class ElementInjector extends TreeNode<ElementInjector> implements Depend
     return isPresent(nestedView) ? nestedView.rootElementInjectors : [];
   }
 
-  afterViewChecked(): void { this._queryStrategy.updateViewQueries(); }
+  ngAfterViewChecked(): void { this._queryStrategy.updateViewQueries(); }
 
-  afterContentChecked(): void { this._queryStrategy.updateContentQueries(); }
+  ngAfterContentChecked(): void { this._queryStrategy.updateContentQueries(); }
 
   traverseAndSetQueriesAsDirty(): void {
     var inj = this;
@@ -810,43 +812,43 @@ class ElementInjectorInlineStrategy implements _ElementInjectorStrategy {
 
     if (p.provider0 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider0).callOnDestroy) {
-      i.obj0.onDestroy();
+      i.obj0.ngOnDestroy();
     }
     if (p.provider1 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider1).callOnDestroy) {
-      i.obj1.onDestroy();
+      i.obj1.ngOnDestroy();
     }
     if (p.provider2 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider2).callOnDestroy) {
-      i.obj2.onDestroy();
+      i.obj2.ngOnDestroy();
     }
     if (p.provider3 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider3).callOnDestroy) {
-      i.obj3.onDestroy();
+      i.obj3.ngOnDestroy();
     }
     if (p.provider4 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider4).callOnDestroy) {
-      i.obj4.onDestroy();
+      i.obj4.ngOnDestroy();
     }
     if (p.provider5 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider5).callOnDestroy) {
-      i.obj5.onDestroy();
+      i.obj5.ngOnDestroy();
     }
     if (p.provider6 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider6).callOnDestroy) {
-      i.obj6.onDestroy();
+      i.obj6.ngOnDestroy();
     }
     if (p.provider7 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider7).callOnDestroy) {
-      i.obj7.onDestroy();
+      i.obj7.ngOnDestroy();
     }
     if (p.provider8 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider8).callOnDestroy) {
-      i.obj8.onDestroy();
+      i.obj8.ngOnDestroy();
     }
     if (p.provider9 instanceof DirectiveProvider &&
         (<DirectiveProvider>p.provider9).callOnDestroy) {
-      i.obj9.onDestroy();
+      i.obj9.ngOnDestroy();
     }
   }
 
@@ -936,7 +938,7 @@ class ElementInjectorDynamicStrategy implements _ElementInjectorStrategy {
     for (var i = 0; i < p.providers.length; i++) {
       if (p.providers[i] instanceof DirectiveProvider &&
           (<DirectiveProvider>p.providers[i]).callOnDestroy) {
-        ist.objs[i].onDestroy();
+        ist.objs[i].ngOnDestroy();
       }
     }
   }
diff --git a/modules/angular2/src/core/linker/interfaces.ts b/modules/angular2/src/core/linker/interfaces.ts
index cf513d39c6..71a7030995 100644
--- a/modules/angular2/src/core/linker/interfaces.ts
+++ b/modules/angular2/src/core/linker/interfaces.ts
@@ -41,7 +41,7 @@ export var LIFECYCLE_HOOKS_VALUES = [
 /**
  * Implement this interface to get notified when any data-bound property of your directive changes.
  *
- * `onChanges` is called right after the data-bound properties have been checked and before view
+ * `ngOnChanges` is called right after the data-bound properties have been checked and before view
  * and content children are checked if at least one of them has changed.
  *
  * The `changes` parameter contains an entry for each of the changed data-bound property. The key is
@@ -57,8 +57,8 @@ export var LIFECYCLE_HOOKS_VALUES = [
  * class MyComponent implements OnChanges {
  *   @Input() myProp: any;
  *
- *   onChanges(changes: {[propName: string]: SimpleChange}) {
- *     console.log('onChanges - myProp = ' + changes['myProp'].currentValue);
+ *   ngOnChanges(changes: {[propName: string]: SimpleChange}) {
+ *     console.log('ngOnChanges - myProp = ' + changes['myProp'].currentValue);
  *   }
  * }
  *
@@ -76,13 +76,13 @@ export var LIFECYCLE_HOOKS_VALUES = [
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface OnChanges { onChanges(changes: {[key: string]: SimpleChange}); }
+export interface OnChanges { ngOnChanges(changes: {[key: string]: SimpleChange}); }
 
 /**
  * Implement this interface to execute custom initialization logic after your directive's
  * data-bound properties have been initialized.
  *
- * `onInit` is called right after the directive's data-bound properties have been checked for the
+ * `ngOnInit` is called right after the directive's data-bound properties have been checked for the
  * first time, and before any of its children have been checked. It is invoked only once when the
  * directive is instantiated.
  *
@@ -94,12 +94,12 @@ export interface OnChanges { onChanges(changes: {[key: string]: SimpleChange});
  *   template: `<p>my-component</p>`
  * })
  * class MyComponent implements OnInit, OnDestroy {
- *   onInit() {
- *     console.log('onInit');
+ *   ngOnInit() {
+ *     console.log('ngOnInit');
  *   }
  *
- *   onDestroy() {
- *     console.log('onDestroy');
+ *   ngOnDestroy() {
+ *     console.log('ngOnDestroy');
  *   }
  * }
  *
@@ -119,29 +119,29 @@ export interface OnChanges { onChanges(changes: {[key: string]: SimpleChange});
  * bootstrap(App).catch(err => console.error(err));
  *  ```
  */
-export interface OnInit { onInit(); }
+export interface OnInit { ngOnInit(); }
 
 /**
  * Implement this interface to override the default change detection algorithm for your directive.
  *
- * `doCheck` gets called to check the changes in the directives instead of the default algorithm.
+ * `ngDoCheck` gets called to check the changes in the directives instead of the default algorithm.
  *
  * The default change detection algorithm looks for differences by comparing bound-property values
  * by reference across change detection runs. When `DoCheck` is implemented, the default algorithm
- * is disabled and `doCheck` is responsible for checking for changes.
+ * is disabled and `ngDoCheck` is responsible for checking for changes.
  *
  * Implementing this interface allows improving performance by using insights about the component,
  * its implementation and data types of its properties.
  *
  * Note that a directive should not implement both `DoCheck` and {@link OnChanges} at the same time.
- * `onChanges` would not be called when a directive implements `DoCheck`. Reaction to the changes
- * have to be handled from within the `doCheck` callback.
+ * `ngOnChanges` would not be called when a directive implements `DoCheck`. Reaction to the changes
+ * have to be handled from within the `ngDoCheck` callback.
  *
  * Use {@link KeyValueDiffers} and {@link IterableDiffers} to add your custom check mechanisms.
  *
  * ### Example ([live demo](http://plnkr.co/edit/QpnIlF0CR2i5bcYbHEUJ?p=preview))
  *
- * In the following example `doCheck` uses an {@link IterableDiffers} to detect the updates to the
+ * In the following example `ngDoCheck` uses an {@link IterableDiffers} to detect the updates to the
  * array `list`:
  *
  * ```typescript
@@ -163,7 +163,7 @@ export interface OnInit { onInit(); }
  *     this.differ = differs.find([]).create(null);
  *   }
  *
- *   doCheck() {
+ *   ngDoCheck() {
  *     var changes = this.differ.diff(this.list);
  *
  *     if (changes) {
@@ -186,12 +186,12 @@ export interface OnInit { onInit(); }
  * }
  * ```
  */
-export interface DoCheck { doCheck(); }
+export interface DoCheck { ngDoCheck(); }
 
 /**
  * Implement this interface to get notified when your directive is destroyed.
  *
- * `onDestroy` callback is typically used for any custom cleanup that needs to occur when the
+ * `ngOnDestroy` callback is typically used for any custom cleanup that needs to occur when the
  * instance is destroyed
  *
  * ### Example ([live example](http://plnkr.co/edit/1MBypRryXd64v4pV03Yn?p=preview))
@@ -202,12 +202,12 @@ export interface DoCheck { doCheck(); }
  *   template: `<p>my-component</p>`
  * })
  * class MyComponent implements OnInit, OnDestroy {
- *   onInit() {
- *     console.log('onInit');
+ *   ngOnInit() {
+ *     console.log('ngOnInit');
  *   }
  *
- *   onDestroy() {
- *     console.log('onDestroy');
+ *   ngOnDestroy() {
+ *     console.log('ngOnDestroy');
  *   }
  * }
  *
@@ -227,7 +227,7 @@ export interface DoCheck { doCheck(); }
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface OnDestroy { onDestroy(); }
+export interface OnDestroy { ngOnDestroy(); }
 
 /**
  * Implement this interface to get notified when your directive's content has been fully
@@ -256,7 +256,7 @@ export interface OnDestroy { onDestroy(); }
  *     console.log(this.getMessage(this.contentChild));
  *   }
  *
- *   afterContentInit() {
+ *   ngAfterContentInit() {
  *     // contentChild is updated after the content has been checked
  *     console.log('AfterContentInit: ' + this.getMessage(this.contentChild));
  *   }
@@ -280,7 +280,7 @@ export interface OnDestroy { onDestroy(); }
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface AfterContentInit { afterContentInit(); }
+export interface AfterContentInit { ngAfterContentInit(); }
 
 /**
  * Implement this interface to get notified after every check of your directive's content.
@@ -302,7 +302,7 @@ export interface AfterContentInit { afterContentInit(); }
  *     console.log(this.getMessage(this.contentChild));
  *   }
  *
- *   afterContentChecked() {
+ *   ngAfterContentChecked() {
  *     // contentChild is updated after the content has been checked
  *     console.log('AfterContentChecked: ' + this.getMessage(this.contentChild));
  *   }
@@ -328,7 +328,7 @@ export interface AfterContentInit { afterContentInit(); }
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface AfterContentChecked { afterContentChecked(); }
+export interface AfterContentChecked { ngAfterContentChecked(); }
 
 /**
  * Implement this interface to get notified when your component's view has been fully initialized.
@@ -354,9 +354,9 @@ export interface AfterContentChecked { afterContentChecked(); }
  *     console.log(this.getMessage(this.viewChild));
  *   }
  *
- *   afterViewInit() {
+ *   ngAfterViewInit() {
  *     // viewChild is updated after the view has been initialized
- *     console.log('afterViewInit: ' + this.getMessage(this.viewChild));
+ *     console.log('ngAfterViewInit: ' + this.getMessage(this.viewChild));
  *   }
  *
  *   private getMessage(cmp: ChildComponent): string {
@@ -375,7 +375,7 @@ export interface AfterContentChecked { afterContentChecked(); }
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface AfterViewInit { afterViewInit(); }
+export interface AfterViewInit { ngAfterViewInit(); }
 
 /**
  * Implement this interface to get notified after every check of your component's view.
@@ -404,7 +404,7 @@ export interface AfterViewInit { afterViewInit(); }
  *     console.log(this.getMessage(this.viewChild));
  *   }
  *
- *   afterViewChecked() {
+ *   ngAfterViewChecked() {
  *     // viewChild is updated after the view has been checked
  *     console.log('AfterViewChecked: ' + this.getMessage(this.viewChild));
  *   }
@@ -425,4 +425,4 @@ export interface AfterViewInit { afterViewInit(); }
  * bootstrap(App).catch(err => console.error(err));
  * ```
  */
-export interface AfterViewChecked { afterViewChecked(); }
+export interface AfterViewChecked { ngAfterViewChecked(); }
diff --git a/modules/angular2/src/core/linker/view.ts b/modules/angular2/src/core/linker/view.ts
index 20e10fe73b..f87e4960ef 100644
--- a/modules/angular2/src/core/linker/view.ts
+++ b/modules/angular2/src/core/linker/view.ts
@@ -182,7 +182,7 @@ export class AppView implements ChangeDispatcher, RenderEventDispatcher {
     var eiCount = this.proto.elementBinders.length;
     var ei = this.elementInjectors;
     for (var i = eiCount - 1; i >= 0; i--) {
-      if (isPresent(ei[i + this.elementOffset])) ei[i + this.elementOffset].afterContentChecked();
+      if (isPresent(ei[i + this.elementOffset])) ei[i + this.elementOffset].ngAfterContentChecked();
     }
   }
 
@@ -190,7 +190,7 @@ export class AppView implements ChangeDispatcher, RenderEventDispatcher {
     var eiCount = this.proto.elementBinders.length;
     var ei = this.elementInjectors;
     for (var i = eiCount - 1; i >= 0; i--) {
-      if (isPresent(ei[i + this.elementOffset])) ei[i + this.elementOffset].afterViewChecked();
+      if (isPresent(ei[i + this.elementOffset])) ei[i + this.elementOffset].ngAfterViewChecked();
     }
   }
 
diff --git a/modules/angular2/src/core/linker/view_manager.ts b/modules/angular2/src/core/linker/view_manager.ts
index 150feaa97d..e11318d309 100644
--- a/modules/angular2/src/core/linker/view_manager.ts
+++ b/modules/angular2/src/core/linker/view_manager.ts
@@ -97,7 +97,7 @@ export abstract class AppViewManager {
    *     Parent (<some-component></some-component>)
    *   `
    * })
-   * class MyApp {
+   * class MyApp implements OnDestroy {
    *   viewRef: ng.ViewRef;
    *
    *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
@@ -106,7 +106,7 @@ export abstract class AppViewManager {
    *     })
    *   }
    *
-   *   onDestroy() {
+   *   ngOnDestroy() {
    *     this.appViewManager.destroyRootHostView(this.viewRef);
    *     this.viewRef = null;
    *   }
diff --git a/modules/angular2/src/core/metadata.ts b/modules/angular2/src/core/metadata.ts
index e75ae4427a..ae275e9520 100644
--- a/modules/angular2/src/core/metadata.ts
+++ b/modules/angular2/src/core/metadata.ts
@@ -1108,7 +1108,7 @@ export var Query: QueryFactory = makeParamDecorator(QueryMetadata);
 /**
  * Configures a content query.
  *
- * Content queries are set before the `afterContentInit` callback is called.
+ * Content queries are set before the `ngAfterContentInit` callback is called.
  *
  * ### Example
  *
@@ -1119,7 +1119,7 @@ export var Query: QueryFactory = makeParamDecorator(QueryMetadata);
  * class SomeDir {
  *   @ContentChildren(ChildDirective) contentChildren: QueryList<ChildDirective>;
  *
- *   afterContentInit() {
+ *   ngAfterContentInit() {
  *     // contentChildren is set
  *   }
  * }
@@ -1131,7 +1131,7 @@ export var ContentChildren: ContentChildrenFactory = makePropDecorator(ContentCh
 /**
  * Configures a content query.
  *
- * Content queries are set before the `afterContentInit` callback is called.
+ * Content queries are set before the `ngAfterContentInit` callback is called.
  *
  * ### Example
  *
@@ -1142,7 +1142,7 @@ export var ContentChildren: ContentChildrenFactory = makePropDecorator(ContentCh
  * class SomeDir {
  *   @ContentChild(ChildDirective) contentChild;
  *
- *   afterContentInit() {
+ *   ngAfterContentInit() {
  *     // contentChild is set
  *   }
  * }
@@ -1154,7 +1154,7 @@ export var ContentChild: ContentChildFactory = makePropDecorator(ContentChildMet
 /**
  * Configures a view query.
  *
- * View queries are set before the `afterViewInit` callback is called.
+ * View queries are set before the `ngAfterViewInit` callback is called.
  *
  * ### Example
  *
@@ -1167,7 +1167,7 @@ export var ContentChild: ContentChildFactory = makePropDecorator(ContentChildMet
  * class SomeDir {
  *   @ViewChildren(ItemDirective) viewChildren: QueryList<ItemDirective>;
  *
- *   afterViewInit() {
+ *   ngAfterViewInit() {
  *     // viewChildren is set
  *   }
  * }
@@ -1179,7 +1179,7 @@ export var ViewChildren: ViewChildrenFactory = makePropDecorator(ViewChildrenMet
 /**
  * Configures a view query.
  *
- * View queries are set before the `afterViewInit` callback is called.
+ * View queries are set before the `ngAfterViewInit` callback is called.
  *
  * ### Example
  *
@@ -1192,7 +1192,7 @@ export var ViewChildren: ViewChildrenFactory = makePropDecorator(ViewChildrenMet
  * class SomeDir {
  *   @ViewChild(ItemDirective) viewChild:ItemDirective;
  *
- *   afterViewInit() {
+ *   ngAfterViewInit() {
  *     // viewChild is set
  *   }
  * }
diff --git a/modules/angular2/src/core/metadata/di.ts b/modules/angular2/src/core/metadata/di.ts
index fb0db7fa21..ee679cb950 100644
--- a/modules/angular2/src/core/metadata/di.ts
+++ b/modules/angular2/src/core/metadata/di.ts
@@ -194,7 +194,7 @@ export class QueryMetadata extends DependencyMetadata {
 /**
  * Configures a content query.
  *
- * Content queries are set before the `afterContentInit` callback is called.
+ * Content queries are set before the `ngAfterContentInit` callback is called.
  *
  * ### Example
  *
@@ -205,7 +205,7 @@ export class QueryMetadata extends DependencyMetadata {
  * class SomeDir {
  *   @ContentChildren(ChildDirective) contentChildren: QueryList<ChildDirective>;
  *
- *   afterContentInit() {
+ *   ngAfterContentInit() {
  *     // contentChildren is set
  *   }
  * }
@@ -222,7 +222,7 @@ export class ContentChildrenMetadata extends QueryMetadata {
 /**
  * Configures a content query.
  *
- * Content queries are set before the `afterContentInit` callback is called.
+ * Content queries are set before the `ngAfterContentInit` callback is called.
  *
  * ### Example
  *
@@ -233,7 +233,7 @@ export class ContentChildrenMetadata extends QueryMetadata {
  * class SomeDir {
  *   @ContentChild(ChildDirective) contentChild;
  *
- *   afterContentInit() {
+ *   ngAfterContentInit() {
  *     // contentChild is set
  *   }
  * }
@@ -296,7 +296,7 @@ export class ViewQueryMetadata extends QueryMetadata {
 /**
  * Configures a view query.
  *
- * View queries are set before the `afterViewInit` callback is called.
+ * View queries are set before the `ngAfterViewInit` callback is called.
  *
  * ### Example
  *
@@ -309,7 +309,7 @@ export class ViewQueryMetadata extends QueryMetadata {
  * class SomeDir {
  *   @ViewChildren(ItemDirective) viewChildren: QueryList<ItemDirective>;
  *
- *   afterViewInit() {
+ *   ngAfterViewInit() {
  *     // viewChildren is set
  *   }
  * }
@@ -323,7 +323,7 @@ export class ViewChildrenMetadata extends ViewQueryMetadata {
 /**
  * Configures a view query.
  *
- * View queries are set before the `afterViewInit` callback is called.
+ * View queries are set before the `ngAfterViewInit` callback is called.
  *
  * ### Example
  *
@@ -336,7 +336,7 @@ export class ViewChildrenMetadata extends ViewQueryMetadata {
  * class SomeDir {
  *   @ViewChild(ItemDirective) viewChild:ItemDirective;
  *
- *   afterViewInit() {
+ *   ngAfterViewInit() {
  *     // viewChild is set
  *   }
  * }
diff --git a/modules/angular2/src/core/metadata/directives.ts b/modules/angular2/src/core/metadata/directives.ts
index 5d1e17438a..0097883d31 100644
--- a/modules/angular2/src/core/metadata/directives.ts
+++ b/modules/angular2/src/core/metadata/directives.ts
@@ -720,8 +720,8 @@ export class DirectiveMetadata extends InjectableMetadata {
   /**
    * Configures the queries that will be injected into the directive.
    *
-   * Content queries are set before the `afterContentInit` callback is called.
-   * View queries are set before the `afterViewInit` callback is called.
+   * Content queries are set before the `ngAfterContentInit` callback is called.
+   * View queries are set before the `ngAfterViewInit` callback is called.
    *
    * ### Example
    *
@@ -739,11 +739,11 @@ export class DirectiveMetadata extends InjectableMetadata {
    *   contentChildren: QueryList<ChildDirective>,
    *   viewChildren: QueryList<ChildDirective>
    *
-   *   afterContentInit() {
+   *   ngAfterContentInit() {
    *     // contentChildren is set
    *   }
    *
-   *   afterViewInit() {
+   *   ngAfterViewInit() {
    *     // viewChildren is set
    *   }
    * }
diff --git a/modules/angular2/src/router/interfaces.ts b/modules/angular2/src/router/interfaces.ts
index e6bc7ec6b5..d3b7464f11 100644
--- a/modules/angular2/src/router/interfaces.ts
+++ b/modules/angular2/src/router/interfaces.ts
@@ -8,34 +8,37 @@ var __ignore_me = global;
 
 
 /**
- * Defines route lifecycle method `onActivate`, which is called by the router at the end of a
+ * Defines route lifecycle method `routerOnActivate`, which is called by the router at the end of a
  * successful route navigation.
  *
  * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
  * will be called depending on the result of {@link CanReuse}.
  *
- * The `onActivate` hook is called with two {@link ComponentInstruction}s as parameters, the first
+ * The `routerOnActivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
  * representing the current route being navigated to, and the second parameter representing the
  * previous route or `null`.
  *
- * If `onActivate` returns a promise, the route change will wait until the promise settles to
+ * If `routerOnActivate` returns a promise, the route change will wait until the promise settles to
  * instantiate and activate child components.
  *
  * ### Example
- * {@example router/ts/on_activate/on_activate_example.ts region='onActivate'}
+ * {@example router/ts/on_activate/on_activate_example.ts region='routerOnActivate'}
  */
 export interface OnActivate {
-  onActivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  routerOnActivate(nextInstruction: ComponentInstruction,
+                   prevInstruction: ComponentInstruction): any;
 }
 
 /**
- * Defines route lifecycle method `onReuse`, which is called by the router at the end of a
+ * Defines route lifecycle method `routerOnReuse`, which is called by the router at the end of a
  * successful route navigation when {@link CanReuse} is implemented and returns or resolves to true.
  *
  * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
  * will be called, depending on the result of {@link CanReuse}.
  *
- * The `onReuse` hook is called with two {@link ComponentInstruction}s as parameters, the first
+ * The `routerOnReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
  * representing the current route being navigated to, and the second parameter representing the
  * previous route or `null`.
  *
@@ -43,65 +46,73 @@ export interface OnActivate {
  * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
  */
 export interface OnReuse {
-  onReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  routerOnReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
 }
 
 /**
- * Defines route lifecycle method `onDeactivate`, which is called by the router before destroying
+ * Defines route lifecycle method `routerOnDeactivate`, which is called by the router before
+ * destroying
  * a component as part of a route change.
  *
- * The `onDeactivate` hook is called with two {@link ComponentInstruction}s as parameters, the first
+ * The `routerOnDeactivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
  * representing the current route being navigated to, and the second parameter representing the
  * previous route.
  *
- * If `onDeactivate` returns a promise, the route change will wait until the promise settles.
+ * If `routerOnDeactivate` returns a promise, the route change will wait until the promise settles.
  *
  * ### Example
- * {@example router/ts/on_deactivate/on_deactivate_example.ts region='onDeactivate'}
+ * {@example router/ts/on_deactivate/on_deactivate_example.ts region='routerOnDeactivate'}
  */
 export interface OnDeactivate {
-  onDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  routerOnDeactivate(nextInstruction: ComponentInstruction,
+                     prevInstruction: ComponentInstruction): any;
 }
 
 /**
- * Defines route lifecycle method `canReuse`, which is called by the router to determine whether a
+ * Defines route lifecycle method `routerCanReuse`, which is called by the router to determine
+ * whether a
  * component should be reused across routes, or whether to destroy and instantiate a new component.
  *
- * The `canReuse` hook is called with two {@link ComponentInstruction}s as parameters, the first
+ * The `routerCanReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
  * representing the current route being navigated to, and the second parameter representing the
  * previous route.
  *
- * If `canReuse` returns or resolves to `true`, the component instance will be reused and the
- * {@link OnDeactivate} hook will be run. If `canReuse` returns or resolves to `false`, a new
+ * If `routerCanReuse` returns or resolves to `true`, the component instance will be reused and the
+ * {@link OnDeactivate} hook will be run. If `routerCanReuse` returns or resolves to `false`, a new
  * component will be instantiated, and the existing component will be deactivated and removed as
  * part of the navigation.
  *
- * If `canReuse` throws or rejects, the navigation will be cancelled.
+ * If `routerCanReuse` throws or rejects, the navigation will be cancelled.
  *
  * ### Example
  * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
  */
 export interface CanReuse {
-  canReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  routerCanReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
 }
 
 /**
- * Defines route lifecycle method `canDeactivate`, which is called by the router to determine
+ * Defines route lifecycle method `routerCanDeactivate`, which is called by the router to determine
  * if a component can be removed as part of a navigation.
  *
- * The `canDeactivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * The `routerCanDeactivate` hook is called with two {@link ComponentInstruction}s as parameters,
+ * the
  * first representing the current route being navigated to, and the second parameter
  * representing the previous route.
  *
- * If `canDeactivate` returns or resolves to `false`, the navigation is cancelled. If it returns or
+ * If `routerCanDeactivate` returns or resolves to `false`, the navigation is cancelled. If it
+ * returns or
  * resolves to `true`, then the navigation continues, and the component will be deactivated
  * (the {@link OnDeactivate} hook will be run) and removed.
  *
- * If `canDeactivate` throws or rejects, the navigation is also cancelled.
+ * If `routerCanDeactivate` throws or rejects, the navigation is also cancelled.
  *
  * ### Example
- * {@example router/ts/can_deactivate/can_deactivate_example.ts region='canDeactivate'}
+ * {@example router/ts/can_deactivate/can_deactivate_example.ts region='routerCanDeactivate'}
  */
 export interface CanDeactivate {
-  canDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  routerCanDeactivate(nextInstruction: ComponentInstruction,
+                      prevInstruction: ComponentInstruction): any;
 }
diff --git a/modules/angular2/src/router/lifecycle_annotations.ts b/modules/angular2/src/router/lifecycle_annotations.ts
index 4f3c8e234c..840f1d2fc5 100644
--- a/modules/angular2/src/router/lifecycle_annotations.ts
+++ b/modules/angular2/src/router/lifecycle_annotations.ts
@@ -9,11 +9,11 @@ import {Promise} from 'angular2/src/facade/async';
 import {ComponentInstruction} from './instruction';
 
 export {
-  canReuse,
-  canDeactivate,
-  onActivate,
-  onReuse,
-  onDeactivate
+  routerCanReuse,
+  routerCanDeactivate,
+  routerOnActivate,
+  routerOnReuse,
+  routerOnDeactivate
 } from './lifecycle_annotations_impl';
 
 /**
diff --git a/modules/angular2/src/router/lifecycle_annotations_impl.ts b/modules/angular2/src/router/lifecycle_annotations_impl.ts
index db3367bc8b..d8c83866ab 100644
--- a/modules/angular2/src/router/lifecycle_annotations_impl.ts
+++ b/modules/angular2/src/router/lifecycle_annotations_impl.ts
@@ -10,9 +10,13 @@ export class CanActivate {
   constructor(public fn: Function) {}
 }
 
-export const canReuse: RouteLifecycleHook = CONST_EXPR(new RouteLifecycleHook("canReuse"));
-export const canDeactivate: RouteLifecycleHook =
-    CONST_EXPR(new RouteLifecycleHook("canDeactivate"));
-export const onActivate: RouteLifecycleHook = CONST_EXPR(new RouteLifecycleHook("onActivate"));
-export const onReuse: RouteLifecycleHook = CONST_EXPR(new RouteLifecycleHook("onReuse"));
-export const onDeactivate: RouteLifecycleHook = CONST_EXPR(new RouteLifecycleHook("onDeactivate"));
+export const routerCanReuse: RouteLifecycleHook =
+    CONST_EXPR(new RouteLifecycleHook("routerCanReuse"));
+export const routerCanDeactivate: RouteLifecycleHook =
+    CONST_EXPR(new RouteLifecycleHook("routerCanDeactivate"));
+export const routerOnActivate: RouteLifecycleHook =
+    CONST_EXPR(new RouteLifecycleHook("routerOnActivate"));
+export const routerOnReuse: RouteLifecycleHook =
+    CONST_EXPR(new RouteLifecycleHook("routerOnReuse"));
+export const routerOnDeactivate: RouteLifecycleHook =
+    CONST_EXPR(new RouteLifecycleHook("routerOnDeactivate"));
diff --git a/modules/angular2/src/router/route_lifecycle_reflector.dart b/modules/angular2/src/router/route_lifecycle_reflector.dart
index afc3362d06..a8301aafc9 100644
--- a/modules/angular2/src/router/route_lifecycle_reflector.dart
+++ b/modules/angular2/src/router/route_lifecycle_reflector.dart
@@ -10,15 +10,15 @@ bool hasLifecycleHook(RouteLifecycleHook e, type) {
   final List interfaces = reflector.interfaces(type);
   var interface;
 
-  if (e == onActivate) {
+  if (e == routerOnActivate) {
     interface = OnActivate;
-  } else if (e == onDeactivate) {
+  } else if (e == routerOnDeactivate) {
     interface = OnDeactivate;
-  } else if (e == onReuse) {
+  } else if (e == routerOnReuse) {
     interface = OnReuse;
-  } else if (e == canDeactivate) {
+  } else if (e == routerCanDeactivate) {
     interface = CanDeactivate;
-  } else if (e == canReuse) {
+  } else if (e == routerCanReuse) {
     interface = CanReuse;
   }
 
diff --git a/modules/angular2/src/router/router.ts b/modules/angular2/src/router/router.ts
index 137ac7db36..b653a1bbd1 100644
--- a/modules/angular2/src/router/router.ts
+++ b/modules/angular2/src/router/router.ts
@@ -202,13 +202,13 @@ export class Router {
   /** @internal */
   _navigate(instruction: Instruction, _skipLocationChange: boolean): Promise<any> {
     return this._settleInstruction(instruction)
-        .then((_) => this._canReuse(instruction))
+        .then((_) => this._routerCanReuse(instruction))
         .then((_) => this._canActivate(instruction))
         .then((result) => {
           if (!result) {
             return false;
           }
-          return this._canDeactivate(instruction)
+          return this._routerCanDeactivate(instruction)
               .then((result) => {
                 if (result) {
                   return this.commit(instruction, _skipLocationChange)
@@ -252,15 +252,15 @@ export class Router {
    * Recursively set reuse flags
    */
   /** @internal */
-  _canReuse(instruction: Instruction): Promise<any> {
+  _routerCanReuse(instruction: Instruction): Promise<any> {
     if (isBlank(this._outlet)) {
       return _resolveToFalse;
     }
-    return this._outlet.canReuse(instruction.component)
+    return this._outlet.routerCanReuse(instruction.component)
         .then((result) => {
           instruction.component.reuse = result;
           if (result && isPresent(this._childRouter) && isPresent(instruction.child)) {
-            return this._childRouter._canReuse(instruction.child);
+            return this._childRouter._routerCanReuse(instruction.child);
           }
         });
   }
@@ -269,7 +269,7 @@ export class Router {
     return canActivateOne(nextInstruction, this._currentInstruction);
   }
 
-  private _canDeactivate(instruction: Instruction): Promise<boolean> {
+  private _routerCanDeactivate(instruction: Instruction): Promise<boolean> {
     if (isBlank(this._outlet)) {
       return _resolveToTrue;
     }
@@ -285,7 +285,7 @@ export class Router {
     if (reuse) {
       next = _resolveToTrue;
     } else {
-      next = this._outlet.canDeactivate(componentInstruction);
+      next = this._outlet.routerCanDeactivate(componentInstruction);
     }
     // TODO: aux route lifecycle hooks
     return next.then((result) => {
@@ -293,7 +293,7 @@ export class Router {
         return false;
       }
       if (isPresent(this._childRouter)) {
-        return this._childRouter._canDeactivate(childInstruction);
+        return this._childRouter._routerCanDeactivate(childInstruction);
       }
       return true;
     });
diff --git a/modules/angular2/src/router/router_outlet.ts b/modules/angular2/src/router/router_outlet.ts
index b8f6a6cfc9..e7e47ac0c8 100644
--- a/modules/angular2/src/router/router_outlet.ts
+++ b/modules/angular2/src/router/router_outlet.ts
@@ -18,6 +18,7 @@ import * as routerMod from './router';
 import {ComponentInstruction, RouteParams, RouteData} from './instruction';
 import * as hookMod from './lifecycle_annotations';
 import {hasLifecycleHook} from './route_lifecycle_reflector';
+import {OnActivate, CanReuse, OnReuse, OnDeactivate, CanDeactivate} from './interfaces';
 
 let _resolveToTrue = PromiseWrapper.resolve(true);
 
@@ -48,7 +49,7 @@ export class RouterOutlet {
 
   /**
    * Called by the Router to instantiate a new component during the commit phase of a navigation.
-   * This method in turn is responsible for calling the `onActivate` hook of its child.
+   * This method in turn is responsible for calling the `routerOnActivate` hook of its child.
    */
   activate(nextInstruction: ComponentInstruction): Promise<any> {
     var previousInstruction = this._currentInstruction;
@@ -64,8 +65,9 @@ export class RouterOutlet {
     return this._loader.loadNextToLocation(componentType, this._elementRef, providers)
         .then((componentRef) => {
           this._componentRef = componentRef;
-          if (hasLifecycleHook(hookMod.onActivate, componentType)) {
-            return this._componentRef.instance.onActivate(nextInstruction, previousInstruction);
+          if (hasLifecycleHook(hookMod.routerOnActivate, componentType)) {
+            return (<OnActivate>this._componentRef.instance)
+                .routerOnActivate(nextInstruction, previousInstruction);
           }
         });
   }
@@ -73,7 +75,7 @@ export class RouterOutlet {
   /**
    * Called by the {@link Router} during the commit phase of a navigation when an outlet
    * reuses a component between different routes.
-   * This method in turn is responsible for calling the `onReuse` hook of its child.
+   * This method in turn is responsible for calling the `routerOnReuse` hook of its child.
    */
   reuse(nextInstruction: ComponentInstruction): Promise<any> {
     var previousInstruction = this._currentInstruction;
@@ -83,21 +85,23 @@ export class RouterOutlet {
       throw new BaseException(`Cannot reuse an outlet that does not contain a component.`);
     }
     return PromiseWrapper.resolve(
-        hasLifecycleHook(hookMod.onReuse, this._currentInstruction.componentType) ?
-            this._componentRef.instance.onReuse(nextInstruction, previousInstruction) :
+        hasLifecycleHook(hookMod.routerOnReuse, this._currentInstruction.componentType) ?
+            (<OnReuse>this._componentRef.instance)
+                .routerOnReuse(nextInstruction, previousInstruction) :
             true);
   }
 
   /**
    * Called by the {@link Router} when an outlet disposes of a component's contents.
-   * This method in turn is responsible for calling the `onDeactivate` hook of its child.
+   * This method in turn is responsible for calling the `routerOnDeactivate` hook of its child.
    */
   deactivate(nextInstruction: ComponentInstruction): Promise<any> {
     var next = _resolveToTrue;
     if (isPresent(this._componentRef) && isPresent(this._currentInstruction) &&
-        hasLifecycleHook(hookMod.onDeactivate, this._currentInstruction.componentType)) {
+        hasLifecycleHook(hookMod.routerOnDeactivate, this._currentInstruction.componentType)) {
       next = PromiseWrapper.resolve(
-          this._componentRef.instance.onDeactivate(nextInstruction, this._currentInstruction));
+          (<OnDeactivate>this._componentRef.instance)
+              .routerOnDeactivate(nextInstruction, this._currentInstruction));
     }
     return next.then((_) => {
       if (isPresent(this._componentRef)) {
@@ -112,16 +116,17 @@ export class RouterOutlet {
    *
    * If this resolves to `false`, the given navigation is cancelled.
    *
-   * This method delegates to the child component's `canDeactivate` hook if it exists,
+   * This method delegates to the child component's `routerCanDeactivate` hook if it exists,
    * and otherwise resolves to true.
    */
-  canDeactivate(nextInstruction: ComponentInstruction): Promise<boolean> {
+  routerCanDeactivate(nextInstruction: ComponentInstruction): Promise<boolean> {
     if (isBlank(this._currentInstruction)) {
       return _resolveToTrue;
     }
-    if (hasLifecycleHook(hookMod.canDeactivate, this._currentInstruction.componentType)) {
+    if (hasLifecycleHook(hookMod.routerCanDeactivate, this._currentInstruction.componentType)) {
       return PromiseWrapper.resolve(
-          this._componentRef.instance.canDeactivate(nextInstruction, this._currentInstruction));
+          (<CanDeactivate>this._componentRef.instance)
+              .routerCanDeactivate(nextInstruction, this._currentInstruction));
     }
     return _resolveToTrue;
   }
@@ -133,17 +138,18 @@ export class RouterOutlet {
    * this will resolve to `false`. You can't reuse an old component when the new component
    * is of a different Type.
    *
-   * Otherwise, this method delegates to the child component's `canReuse` hook if it exists,
+   * Otherwise, this method delegates to the child component's `routerCanReuse` hook if it exists,
    * or resolves to true if the hook is not present.
    */
-  canReuse(nextInstruction: ComponentInstruction): Promise<boolean> {
+  routerCanReuse(nextInstruction: ComponentInstruction): Promise<boolean> {
     var result;
 
     if (isBlank(this._currentInstruction) ||
         this._currentInstruction.componentType != nextInstruction.componentType) {
       result = false;
-    } else if (hasLifecycleHook(hookMod.canReuse, this._currentInstruction.componentType)) {
-      result = this._componentRef.instance.canReuse(nextInstruction, this._currentInstruction);
+    } else if (hasLifecycleHook(hookMod.routerCanReuse, this._currentInstruction.componentType)) {
+      result = (<CanReuse>this._componentRef.instance)
+                   .routerCanReuse(nextInstruction, this._currentInstruction);
     } else {
       result = nextInstruction == this._currentInstruction ||
                (isPresent(nextInstruction.params) && isPresent(this._currentInstruction.params) &&
diff --git a/modules/angular2/src/upgrade/downgrade_ng2_adapter.ts b/modules/angular2/src/upgrade/downgrade_ng2_adapter.ts
index f4e9ec4903..8ac6e9900e 100644
--- a/modules/angular2/src/upgrade/downgrade_ng2_adapter.ts
+++ b/modules/angular2/src/upgrade/downgrade_ng2_adapter.ts
@@ -5,6 +5,7 @@ import {
   ChangeDetectorRef,
   HostViewRef,
   Injector,
+  OnChanges,
   ProtoViewRef,
   SimpleChange
 } from 'angular2/angular2';
@@ -91,13 +92,13 @@ export class DowngradeNg2ComponentAdapter {
     }
 
     var prototype = this.info.type.prototype;
-    if (prototype && prototype.onChanges) {
+    if (prototype && (<OnChanges>prototype).ngOnChanges) {
       // Detect: OnChanges interface
       this.inputChanges = {};
       this.componentScope.$watch(() => this.inputChangeCount, () => {
         var inputChanges = this.inputChanges;
         this.inputChanges = {};
-        this.component.onChanges(inputChanges);
+        (<OnChanges>this.component).ngOnChanges(inputChanges);
       });
     }
     this.componentScope.$watch(() => this.changeDetector && this.changeDetector.detectChanges());
diff --git a/modules/angular2/src/upgrade/upgrade_ng1_adapter.ts b/modules/angular2/src/upgrade/upgrade_ng1_adapter.ts
index 880533c119..6a9d560243 100644
--- a/modules/angular2/src/upgrade/upgrade_ng1_adapter.ts
+++ b/modules/angular2/src/upgrade/upgrade_ng1_adapter.ts
@@ -53,8 +53,8 @@ export class UpgradeNg1ComponentAdapterBuilder {
                       self.outputs, self.propertyOutputs, self.checkProperties, self.propertyMap);
                 }
               ],
-              onChanges: function() { /* needs to be here for ng2 to properly detect it */ },
-              doCheck: function() { /* needs to be here for ng2 to properly detect it */ }
+              ngOnChanges: function() { /* needs to be here for ng2 to properly detect it */ },
+              ngDoCheck: function() { /* needs to be here for ng2 to properly detect it */ }
             });
   }
 
@@ -224,7 +224,7 @@ class UpgradeNg1ComponentAdapter implements OnChanges, DoCheck {
     }
   }
 
-  onChanges(changes: {[name: string]: SimpleChange}) {
+  ngOnChanges(changes: {[name: string]: SimpleChange}) {
     for (var name in changes) {
       if ((<Object>changes).hasOwnProperty(name)) {
         var change: SimpleChange = changes[name];
@@ -233,7 +233,7 @@ class UpgradeNg1ComponentAdapter implements OnChanges, DoCheck {
     }
   }
 
-  doCheck(): number {
+  ngDoCheck(): number {
     var count = 0;
     var destinationObj = this.destinationObj;
     var lastValues = this.checkLastValues;
diff --git a/modules/angular2/test/common/forms/directives_spec.ts b/modules/angular2/test/common/forms/directives_spec.ts
index b8c532fbe3..7c55b760e8 100644
--- a/modules/angular2/test/common/forms/directives_spec.ts
+++ b/modules/angular2/test/common/forms/directives_spec.ts
@@ -256,13 +256,13 @@ export function main() {
         });
       });
 
-      describe("onChanges", () => {
+      describe("ngOnChanges", () => {
         it("should update dom values of all the directives", () => {
           form.addControl(loginControlDir);
 
           (<Control>formModel.find(["login"])).updateValue("new value");
 
-          form.onChanges({});
+          form.ngOnChanges({});
 
           expect((<any>loginControlDir.valueAccessor).writtenValue).toEqual("new value");
         });
@@ -271,7 +271,7 @@ export function main() {
           var formValidator = (c) => ({"custom": true});
           var f = new NgFormModel([formValidator], []);
           f.form = formModel;
-          f.onChanges({"form": new SimpleChange(null, null)});
+          f.ngOnChanges({"form": new SimpleChange(null, null)});
 
           expect(formModel.errors).toEqual({"custom": true});
         });
@@ -279,7 +279,7 @@ export function main() {
         it("should set up an async validator", fakeAsync(() => {
              var f = new NgFormModel([], [asyncValidator("expected")]);
              f.form = formModel;
-             f.onChanges({"form": new SimpleChange(null, null)});
+             f.ngOnChanges({"form": new SimpleChange(null, null)});
 
              tick();
 
@@ -417,7 +417,7 @@ export function main() {
       it("should reexport new control properties", () => {
         var newControl = new Control(null);
         controlDir.form = newControl;
-        controlDir.onChanges({"form": new SimpleChange(control, newControl)});
+        controlDir.ngOnChanges({"form": new SimpleChange(control, newControl)});
 
         checkProperties(newControl);
       });
@@ -426,7 +426,7 @@ export function main() {
         expect(control.valid).toBe(true);
 
         // this will add the required validator and recalculate the validity
-        controlDir.onChanges({"form": new SimpleChange(null, control)});
+        controlDir.ngOnChanges({"form": new SimpleChange(null, control)});
 
         expect(control.valid).toBe(false);
       });
@@ -455,7 +455,7 @@ export function main() {
 
       it("should set up validator", fakeAsync(() => {
            // this will add the required validator and recalculate the validity
-           ngModel.onChanges({});
+           ngModel.ngOnChanges({});
            tick();
 
            expect(ngModel.control.errors).toEqual({"required": true});
diff --git a/modules/angular2/test/common/forms/model_spec.ts b/modules/angular2/test/common/forms/model_spec.ts
index b5eeb4f374..9dc4c2a989 100644
--- a/modules/angular2/test/common/forms/model_spec.ts
+++ b/modules/angular2/test/common/forms/model_spec.ts
@@ -153,13 +153,13 @@ export function main() {
           expect(c.value).toEqual("newValue");
         });
 
-        it("should invoke onChanges if it is present", () => {
-          var onChanges;
-          c.registerOnChange((v) => onChanges = ["invoked", v]);
+        it("should invoke ngOnChanges if it is present", () => {
+          var ngOnChanges;
+          c.registerOnChange((v) => ngOnChanges = ["invoked", v]);
 
           c.updateValue("newValue");
 
-          expect(onChanges).toEqual(["invoked", "newValue"]);
+          expect(ngOnChanges).toEqual(["invoked", "newValue"]);
         });
 
         it("should not invoke on change when explicitly specified", () => {
diff --git a/modules/angular2/test/compiler/runtime_metadata_spec.ts b/modules/angular2/test/compiler/runtime_metadata_spec.ts
index a5c3bb1de0..46fd18e409 100644
--- a/modules/angular2/test/compiler/runtime_metadata_spec.ts
+++ b/modules/angular2/test/compiler/runtime_metadata_spec.ts
@@ -136,12 +136,12 @@ class DirectiveWithoutModuleId {
 class ComponentWithEverything implements OnChanges,
     OnInit, DoCheck, OnDestroy, AfterContentInit, AfterContentChecked, AfterViewInit,
     AfterViewChecked {
-  onChanges(changes: {[key: string]: SimpleChange}): void {}
-  onInit(): void {}
-  doCheck(): void {}
-  onDestroy(): void {}
-  afterContentInit(): void {}
-  afterContentChecked(): void {}
-  afterViewInit(): void {}
-  afterViewChecked(): void {}
+  ngOnChanges(changes: {[key: string]: SimpleChange}): void {}
+  ngOnInit(): void {}
+  ngDoCheck(): void {}
+  ngOnDestroy(): void {}
+  ngAfterContentInit(): void {}
+  ngAfterContentChecked(): void {}
+  ngAfterViewInit(): void {}
+  ngAfterViewChecked(): void {}
 }
diff --git a/modules/angular2/test/core/change_detection/change_detector_spec.ts b/modules/angular2/test/core/change_detection/change_detector_spec.ts
index 114f7264ef..b45ec9eb5b 100644
--- a/modules/angular2/test/core/change_detection/change_detector_spec.ts
+++ b/modules/angular2/test/core/change_detection/change_detector_spec.ts
@@ -468,13 +468,13 @@ export function main() {
         it('should notify the dispatcher after content children have checked', () => {
           var val = _createChangeDetector('name', new Person('bob'));
           val.changeDetector.detectChanges();
-          expect(val.dispatcher.afterContentCheckedCalled).toEqual(true);
+          expect(val.dispatcher.ngAfterContentCheckedCalled).toEqual(true);
         });
 
         it('should notify the dispatcher after view children have been checked', () => {
           var val = _createChangeDetector('name', new Person('bob'));
           val.changeDetector.detectChanges();
-          expect(val.dispatcher.afterViewCheckedCalled).toEqual(true);
+          expect(val.dispatcher.ngAfterViewCheckedCalled).toEqual(true);
         });
 
         describe('updating directives', () => {
@@ -498,7 +498,7 @@ export function main() {
           });
 
           describe('lifecycle', () => {
-            describe('onChanges', () => {
+            describe('ngOnChanges', () => {
               it('should notify the directive when a group of records changes', () => {
                 var cd = _createWithoutHydrate('groupChanges').changeDetector;
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1, directive2], []),
@@ -509,32 +509,32 @@ export function main() {
               });
             });
 
-            describe('doCheck', () => {
+            describe('ngDoCheck', () => {
               it('should notify the directive when it is checked', () => {
                 var cd = _createWithoutHydrate('directiveDoCheck').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
                 cd.detectChanges();
 
-                expect(directive1.doCheckCalled).toBe(true);
-                directive1.doCheckCalled = false;
+                expect(directive1.ngDoCheckCalled).toBe(true);
+                directive1.ngDoCheckCalled = false;
 
                 cd.detectChanges();
-                expect(directive1.doCheckCalled).toBe(true);
+                expect(directive1.ngDoCheckCalled).toBe(true);
               });
 
-              it('should not call doCheck in detectNoChanges', () => {
+              it('should not call ngDoCheck in detectNoChanges', () => {
                 var cd = _createWithoutHydrate('directiveDoCheck').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.checkNoChanges();
 
-                expect(directive1.doCheckCalled).toBe(false);
+                expect(directive1.ngDoCheckCalled).toBe(false);
               });
             });
 
-            describe('onInit', () => {
+            describe('ngOnInit', () => {
               it('should notify the directive after it has been checked the first time', () => {
                 var cd = _createWithoutHydrate('directiveOnInit').changeDetector;
 
@@ -543,51 +543,51 @@ export function main() {
 
                 cd.detectChanges();
 
-                expect(directive1.onInitCalled).toBe(true);
+                expect(directive1.ngOnInitCalled).toBe(true);
 
-                directive1.onInitCalled = false;
+                directive1.ngOnInitCalled = false;
 
                 cd.detectChanges();
 
-                expect(directive1.onInitCalled).toBe(false);
+                expect(directive1.ngOnInitCalled).toBe(false);
               });
 
-              it('should not call onInit in detectNoChanges', () => {
+              it('should not call ngOnInit in detectNoChanges', () => {
                 var cd = _createWithoutHydrate('directiveOnInit').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.checkNoChanges();
 
-                expect(directive1.onInitCalled).toBe(false);
+                expect(directive1.ngOnInitCalled).toBe(false);
               });
 
-              it('should not call onInit again if it throws', () => {
+              it('should not call ngOnInit again if it throws', () => {
                 var cd = _createWithoutHydrate('directiveOnInit').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive3], []), null);
                 var errored = false;
-                // First pass fails, but onInit should be called.
+                // First pass fails, but ngOnInit should be called.
                 try {
                   cd.detectChanges();
                 } catch (e) {
                   errored = true;
                 }
                 expect(errored).toBe(true);
-                expect(directive3.onInitCalled).toBe(true);
-                directive3.onInitCalled = false;
+                expect(directive3.ngOnInitCalled).toBe(true);
+                directive3.ngOnInitCalled = false;
 
-                // Second change detection also fails, but this time onInit should not be called.
+                // Second change detection also fails, but this time ngOnInit should not be called.
                 try {
                   cd.detectChanges();
                 } catch (e) {
                   throw new BaseException("Second detectChanges() should not have run detection.");
                 }
-                expect(directive3.onInitCalled).toBe(false);
+                expect(directive3.ngOnInitCalled).toBe(false);
               });
             });
 
-            describe('afterContentInit', () => {
+            describe('ngAfterContentInit', () => {
               it('should be called after processing the content children', () => {
                 var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1, directive2], []),
@@ -595,38 +595,38 @@ export function main() {
 
                 cd.detectChanges();
 
-                expect(directive1.afterContentInitCalled).toBe(true);
-                expect(directive2.afterContentInitCalled).toBe(true);
+                expect(directive1.ngAfterContentInitCalled).toBe(true);
+                expect(directive2.ngAfterContentInitCalled).toBe(true);
 
                 // reset directives
-                directive1.afterContentInitCalled = false;
-                directive2.afterContentInitCalled = false;
+                directive1.ngAfterContentInitCalled = false;
+                directive2.ngAfterContentInitCalled = false;
 
                 // Verify that checking should not call them.
                 cd.checkNoChanges();
 
-                expect(directive1.afterContentInitCalled).toBe(false);
-                expect(directive2.afterContentInitCalled).toBe(false);
+                expect(directive1.ngAfterContentInitCalled).toBe(false);
+                expect(directive2.ngAfterContentInitCalled).toBe(false);
 
                 // re-verify that changes should not call them
                 cd.detectChanges();
 
-                expect(directive1.afterContentInitCalled).toBe(false);
-                expect(directive2.afterContentInitCalled).toBe(false);
+                expect(directive1.ngAfterContentInitCalled).toBe(false);
+                expect(directive2.ngAfterContentInitCalled).toBe(false);
               });
 
-              it('should not be called when afterContentInit is false', () => {
+              it('should not be called when ngAfterContentInit is false', () => {
                 var cd = _createWithoutHydrate('noCallbacks').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.detectChanges();
 
-                expect(directive1.afterContentInitCalled).toEqual(false);
+                expect(directive1.ngAfterContentInitCalled).toEqual(false);
               });
             });
 
-            describe('afterContentChecked', () => {
+            describe('ngAfterContentChecked', () => {
               it('should be called after processing all the children', () => {
                 var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1, directive2], []),
@@ -634,50 +634,50 @@ export function main() {
 
                 cd.detectChanges();
 
-                expect(directive1.afterContentCheckedCalled).toBe(true);
-                expect(directive2.afterContentCheckedCalled).toBe(true);
+                expect(directive1.ngAfterContentCheckedCalled).toBe(true);
+                expect(directive2.ngAfterContentCheckedCalled).toBe(true);
 
                 // reset directives
-                directive1.afterContentCheckedCalled = false;
-                directive2.afterContentCheckedCalled = false;
+                directive1.ngAfterContentCheckedCalled = false;
+                directive2.ngAfterContentCheckedCalled = false;
 
                 // Verify that checking should not call them.
                 cd.checkNoChanges();
 
-                expect(directive1.afterContentCheckedCalled).toBe(false);
-                expect(directive2.afterContentCheckedCalled).toBe(false);
+                expect(directive1.ngAfterContentCheckedCalled).toBe(false);
+                expect(directive2.ngAfterContentCheckedCalled).toBe(false);
 
                 // re-verify that changes are still detected
                 cd.detectChanges();
 
-                expect(directive1.afterContentCheckedCalled).toBe(true);
-                expect(directive2.afterContentCheckedCalled).toBe(true);
+                expect(directive1.ngAfterContentCheckedCalled).toBe(true);
+                expect(directive2.ngAfterContentCheckedCalled).toBe(true);
               });
 
-              it('should not be called when afterContentChecked is false', () => {
+              it('should not be called when ngAfterContentChecked is false', () => {
                 var cd = _createWithoutHydrate('noCallbacks').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.detectChanges();
 
-                expect(directive1.afterContentCheckedCalled).toEqual(false);
+                expect(directive1.ngAfterContentCheckedCalled).toEqual(false);
               });
 
               it('should be called in reverse order so the child is always notified before the parent',
                  () => {
                    var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
 
-                   var onChangesDoneCalls = [];
+                   var ngOnChangesDoneCalls = [];
                    var td1;
-                   td1 = new TestDirective(() => onChangesDoneCalls.push(td1));
+                   td1 = new TestDirective(() => ngOnChangesDoneCalls.push(td1));
                    var td2;
-                   td2 = new TestDirective(() => onChangesDoneCalls.push(td2));
+                   td2 = new TestDirective(() => ngOnChangesDoneCalls.push(td2));
                    cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([td1, td2], []), null);
 
                    cd.detectChanges();
 
-                   expect(onChangesDoneCalls).toEqual([td2, td1]);
+                   expect(ngOnChangesDoneCalls).toEqual([td2, td1]);
                  });
 
               it('should be called before processing view children', () => {
@@ -705,7 +705,7 @@ export function main() {
             });
 
 
-            describe('afterViewInit', () => {
+            describe('ngAfterViewInit', () => {
               it('should be called after processing the view children', () => {
                 var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1, directive2], []),
@@ -713,39 +713,39 @@ export function main() {
 
                 cd.detectChanges();
 
-                expect(directive1.afterViewInitCalled).toBe(true);
-                expect(directive2.afterViewInitCalled).toBe(true);
+                expect(directive1.ngAfterViewInitCalled).toBe(true);
+                expect(directive2.ngAfterViewInitCalled).toBe(true);
 
                 // reset directives
-                directive1.afterViewInitCalled = false;
-                directive2.afterViewInitCalled = false;
+                directive1.ngAfterViewInitCalled = false;
+                directive2.ngAfterViewInitCalled = false;
 
                 // Verify that checking should not call them.
                 cd.checkNoChanges();
 
-                expect(directive1.afterViewInitCalled).toBe(false);
-                expect(directive2.afterViewInitCalled).toBe(false);
+                expect(directive1.ngAfterViewInitCalled).toBe(false);
+                expect(directive2.ngAfterViewInitCalled).toBe(false);
 
                 // re-verify that changes should not call them
                 cd.detectChanges();
 
-                expect(directive1.afterViewInitCalled).toBe(false);
-                expect(directive2.afterViewInitCalled).toBe(false);
+                expect(directive1.ngAfterViewInitCalled).toBe(false);
+                expect(directive2.ngAfterViewInitCalled).toBe(false);
               });
 
 
-              it('should not be called when afterViewInit is false', () => {
+              it('should not be called when ngAfterViewInit is false', () => {
                 var cd = _createWithoutHydrate('noCallbacks').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.detectChanges();
 
-                expect(directive1.afterViewInitCalled).toEqual(false);
+                expect(directive1.ngAfterViewInitCalled).toEqual(false);
               });
             });
 
-            describe('afterViewChecked', () => {
+            describe('ngAfterViewChecked', () => {
               it('should be called after processing the view children', () => {
                 var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1, directive2], []),
@@ -753,50 +753,50 @@ export function main() {
 
                 cd.detectChanges();
 
-                expect(directive1.afterViewCheckedCalled).toBe(true);
-                expect(directive2.afterViewCheckedCalled).toBe(true);
+                expect(directive1.ngAfterViewCheckedCalled).toBe(true);
+                expect(directive2.ngAfterViewCheckedCalled).toBe(true);
 
                 // reset directives
-                directive1.afterViewCheckedCalled = false;
-                directive2.afterViewCheckedCalled = false;
+                directive1.ngAfterViewCheckedCalled = false;
+                directive2.ngAfterViewCheckedCalled = false;
 
                 // Verify that checking should not call them.
                 cd.checkNoChanges();
 
-                expect(directive1.afterViewCheckedCalled).toBe(false);
-                expect(directive2.afterViewCheckedCalled).toBe(false);
+                expect(directive1.ngAfterViewCheckedCalled).toBe(false);
+                expect(directive2.ngAfterViewCheckedCalled).toBe(false);
 
                 // re-verify that changes should call them
                 cd.detectChanges();
 
-                expect(directive1.afterViewCheckedCalled).toBe(true);
-                expect(directive2.afterViewCheckedCalled).toBe(true);
+                expect(directive1.ngAfterViewCheckedCalled).toBe(true);
+                expect(directive2.ngAfterViewCheckedCalled).toBe(true);
               });
 
-              it('should not be called when afterViewChecked is false', () => {
+              it('should not be called when ngAfterViewChecked is false', () => {
                 var cd = _createWithoutHydrate('noCallbacks').changeDetector;
 
                 cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([directive1], []), null);
 
                 cd.detectChanges();
 
-                expect(directive1.afterViewCheckedCalled).toEqual(false);
+                expect(directive1.ngAfterViewCheckedCalled).toEqual(false);
               });
 
               it('should be called in reverse order so the child is always notified before the parent',
                  () => {
                    var cd = _createWithoutHydrate('emptyWithDirectiveRecords').changeDetector;
 
-                   var onChangesDoneCalls = [];
+                   var ngOnChangesDoneCalls = [];
                    var td1;
-                   td1 = new TestDirective(null, () => onChangesDoneCalls.push(td1));
+                   td1 = new TestDirective(null, () => ngOnChangesDoneCalls.push(td1));
                    var td2;
-                   td2 = new TestDirective(null, () => onChangesDoneCalls.push(td2));
+                   td2 = new TestDirective(null, () => ngOnChangesDoneCalls.push(td2));
                    cd.hydrate(_DEFAULT_CONTEXT, null, new FakeDirectives([td1, td2], []), null);
 
                    cd.detectChanges();
 
-                   expect(onChangesDoneCalls).toEqual([td2, td1]);
+                   expect(ngOnChangesDoneCalls).toEqual([td2, td1]);
                  });
 
               it('should be called after processing view children', () => {
@@ -1408,51 +1408,51 @@ class TestDirective {
   a;
   b;
   changes;
-  doCheckCalled = false;
-  onInitCalled = false;
+  ngDoCheckCalled = false;
+  ngOnInitCalled = false;
 
-  afterContentInitCalled = false;
-  afterContentCheckedCalled = false;
+  ngAfterContentInitCalled = false;
+  ngAfterContentCheckedCalled = false;
 
-  afterViewInitCalled = false;
-  afterViewCheckedCalled = false;
+  ngAfterViewInitCalled = false;
+  ngAfterViewCheckedCalled = false;
   event;
 
-  constructor(public afterContentCheckedSpy = null, public afterViewCheckedSpy = null,
+  constructor(public ngAfterContentCheckedSpy = null, public ngAfterViewCheckedSpy = null,
               public throwOnInit = false) {}
 
   onEvent(event) { this.event = event; }
 
-  doCheck() { this.doCheckCalled = true; }
+  ngDoCheck() { this.ngDoCheckCalled = true; }
 
-  onInit() {
-    this.onInitCalled = true;
+  ngOnInit() {
+    this.ngOnInitCalled = true;
     if (this.throwOnInit) {
-      throw "simulated onInit failure";
+      throw "simulated ngOnInit failure";
     }
   }
 
-  onChanges(changes) {
+  ngOnChanges(changes) {
     var r = {};
     StringMapWrapper.forEach(changes, (c, key) => r[key] = c.currentValue);
     this.changes = r;
   }
 
-  afterContentInit() { this.afterContentInitCalled = true; }
+  ngAfterContentInit() { this.ngAfterContentInitCalled = true; }
 
-  afterContentChecked() {
-    this.afterContentCheckedCalled = true;
-    if (isPresent(this.afterContentCheckedSpy)) {
-      this.afterContentCheckedSpy();
+  ngAfterContentChecked() {
+    this.ngAfterContentCheckedCalled = true;
+    if (isPresent(this.ngAfterContentCheckedSpy)) {
+      this.ngAfterContentCheckedSpy();
     }
   }
 
-  afterViewInit() { this.afterViewInitCalled = true; }
+  ngAfterViewInit() { this.ngAfterViewInitCalled = true; }
 
-  afterViewChecked() {
-    this.afterViewCheckedCalled = true;
-    if (isPresent(this.afterViewCheckedSpy)) {
-      this.afterViewCheckedSpy();
+  ngAfterViewChecked() {
+    this.ngAfterViewCheckedCalled = true;
+    if (isPresent(this.ngAfterViewCheckedSpy)) {
+      this.ngAfterViewCheckedSpy();
     }
   }
 }
@@ -1531,8 +1531,8 @@ class TestDispatcher implements ChangeDispatcher {
   log: string[];
   debugLog: string[];
   loggedValues: any[];
-  afterContentCheckedCalled: boolean = false;
-  afterViewCheckedCalled: boolean = false;
+  ngAfterContentCheckedCalled: boolean = false;
+  ngAfterViewCheckedCalled: boolean = false;
 
   constructor() { this.clear(); }
 
@@ -1540,7 +1540,7 @@ class TestDispatcher implements ChangeDispatcher {
     this.log = [];
     this.debugLog = [];
     this.loggedValues = [];
-    this.afterContentCheckedCalled = true;
+    this.ngAfterContentCheckedCalled = true;
   }
 
   notifyOnBinding(target, value) {
@@ -1550,8 +1550,8 @@ class TestDispatcher implements ChangeDispatcher {
 
   logBindingUpdate(target, value) { this.debugLog.push(`${target.name}=${this._asString(value)}`); }
 
-  notifyAfterContentChecked() { this.afterContentCheckedCalled = true; }
-  notifyAfterViewChecked() { this.afterViewCheckedCalled = true; }
+  notifyAfterContentChecked() { this.ngAfterContentCheckedCalled = true; }
+  notifyAfterViewChecked() { this.ngAfterViewCheckedCalled = true; }
 
   getDebugContext(a, b) { return null; }
 
diff --git a/modules/angular2/test/core/change_detection/coalesce_spec.ts b/modules/angular2/test/core/change_detection/coalesce_spec.ts
index 1f862dddf4..de8feb446a 100644
--- a/modules/angular2/test/core/change_detection/coalesce_spec.ts
+++ b/modules/angular2/test/core/change_detection/coalesce_spec.ts
@@ -84,8 +84,8 @@ export function main() {
 
     it("should not coalesce directive lifecycle records", () => {
       var rs = coalesce([
-        r("doCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle}),
-        r("doCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle})
+        r("ngDoCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle}),
+        r("ngDoCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle})
       ]);
 
       expect(rs.length).toEqual(2);
diff --git a/modules/angular2/test/core/directive_lifecycle_integration_spec.ts b/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
index 59987339fb..b9ddc23396 100644
--- a/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
+++ b/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
@@ -27,7 +27,7 @@ import {Directive, Component, View, ViewMetadata} from 'angular2/src/core/metada
 export function main() {
   describe('directive lifecycle integration spec', () => {
 
-    it('should invoke lifecycle methods onChanges > onInit > doCheck > afterContentChecked',
+    it('should invoke lifecycle methods ngOnChanges > ngOnInit > ngDoCheck > ngAfterContentChecked',
        inject([TestComponentBuilder, Log, AsyncTestCompleter], (tcb: TestComponentBuilder, log: Log,
                                                                 async) => {
          tcb.overrideView(
@@ -40,14 +40,15 @@ export function main() {
 
                expect(log.result())
                    .toEqual(
-                       "onChanges; onInit; doCheck; afterContentInit; afterContentChecked; child_doCheck; " +
-                       "afterViewInit; afterViewChecked");
+                       "ngOnChanges; ngOnInit; ngDoCheck; ngAfterContentInit; ngAfterContentChecked; child_ngDoCheck; " +
+                       "ngAfterViewInit; ngAfterViewChecked");
 
                log.clear();
                tc.detectChanges();
 
                expect(log.result())
-                   .toEqual("doCheck; afterContentChecked; child_doCheck; afterViewChecked");
+                   .toEqual(
+                       "ngDoCheck; ngAfterContentChecked; child_ngDoCheck; ngAfterViewChecked");
 
                async.done();
              });
@@ -59,7 +60,7 @@ export function main() {
 @Directive({selector: '[lifecycle-dir]'})
 class LifecycleDir implements DoCheck {
   constructor(private _log: Log) {}
-  doCheck() { this._log.add("child_doCheck"); }
+  ngDoCheck() { this._log.add("child_ngDoCheck"); }
 }
 
 @Component({selector: "[lifecycle]", inputs: ['field']})
@@ -69,19 +70,19 @@ class LifecycleCmp implements OnChanges, OnInit, DoCheck, AfterContentInit, Afte
   field;
   constructor(private _log: Log) {}
 
-  onChanges(_) { this._log.add("onChanges"); }
+  ngOnChanges(_) { this._log.add("ngOnChanges"); }
 
-  onInit() { this._log.add("onInit"); }
+  ngOnInit() { this._log.add("ngOnInit"); }
 
-  doCheck() { this._log.add("doCheck"); }
+  ngDoCheck() { this._log.add("ngDoCheck"); }
 
-  afterContentInit() { this._log.add("afterContentInit"); }
+  ngAfterContentInit() { this._log.add("ngAfterContentInit"); }
 
-  afterContentChecked() { this._log.add("afterContentChecked"); }
+  ngAfterContentChecked() { this._log.add("ngAfterContentChecked"); }
 
-  afterViewInit() { this._log.add("afterViewInit"); }
+  ngAfterViewInit() { this._log.add("ngAfterViewInit"); }
 
-  afterViewChecked() { this._log.add("afterViewChecked"); }
+  ngAfterViewChecked() { this._log.add("ngAfterViewChecked"); }
 }
 
 @Component({selector: 'my-comp'})
diff --git a/modules/angular2/test/core/linker/directive_lifecycle_spec.dart b/modules/angular2/test/core/linker/directive_lifecycle_spec.dart
index 321ff61d9d..87441b0d2b 100644
--- a/modules/angular2/test/core/linker/directive_lifecycle_spec.dart
+++ b/modules/angular2/test/core/linker/directive_lifecycle_spec.dart
@@ -7,8 +7,8 @@ import 'package:angular2/src/core/linker/interfaces.dart';
 main() {
   describe('Create DirectiveMetadata', () {
     describe('lifecycle', () {
-      describe("onChanges", () {
-        it("should be true when the directive has the onChanges method", () {
+      describe("ngOnChanges", () {
+        it("should be true when the directive has the ngOnChanges method", () {
           expect(hasLifecycleHook(
                   LifecycleHooks.OnChanges, DirectiveImplementingOnChanges))
               .toBe(true);
@@ -20,8 +20,8 @@ main() {
         });
       });
 
-      describe("onDestroy", () {
-        it("should be true when the directive has the onDestroy method", () {
+      describe("ngOnDestroy", () {
+        it("should be true when the directive has the ngOnDestroy method", () {
           expect(hasLifecycleHook(
                   LifecycleHooks.OnDestroy, DirectiveImplementingOnDestroy))
               .toBe(true);
@@ -33,8 +33,8 @@ main() {
         });
       });
 
-      describe("onInit", () {
-        it("should be true when the directive has the onInit method", () {
+      describe("ngOnInit", () {
+        it("should be true when the directive has the ngOnInit method", () {
           expect(hasLifecycleHook(
               LifecycleHooks.OnInit, DirectiveImplementingOnInit)).toBe(true);
         });
@@ -45,8 +45,8 @@ main() {
         });
       });
 
-      describe("doCheck", () {
-        it("should be true when the directive has the doCheck method", () {
+      describe("ngDoCheck", () {
+        it("should be true when the directive has the ngDoCheck method", () {
           expect(hasLifecycleHook(
               LifecycleHooks.DoCheck, DirectiveImplementingOnCheck)).toBe(true);
         });
@@ -57,8 +57,8 @@ main() {
         });
       });
 
-      describe("afterContentInit", () {
-        it("should be true when the directive has the afterContentInit method",
+      describe("ngAfterContentInit", () {
+        it("should be true when the directive has the ngAfterContentInit method",
             () {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentInit,
               DirectiveImplementingAfterContentInit)).toBe(true);
@@ -70,8 +70,8 @@ main() {
         });
       });
 
-      describe("afterContentChecked", () {
-        it("should be true when the directive has the afterContentChecked method",
+      describe("ngAfterContentChecked", () {
+        it("should be true when the directive has the ngAfterContentChecked method",
             () {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentChecked,
               DirectiveImplementingAfterContentChecked)).toBe(true);
@@ -84,8 +84,8 @@ main() {
         });
       });
 
-      describe("afterViewInit", () {
-        it("should be true when the directive has the afterViewInit method",
+      describe("ngAfterViewInit", () {
+        it("should be true when the directive has the ngAfterViewInit method",
             () {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewInit,
               DirectiveImplementingAfterViewInit)).toBe(true);
@@ -97,8 +97,8 @@ main() {
         });
       });
 
-      describe("afterViewChecked", () {
-        it("should be true when the directive has the afterViewChecked method",
+      describe("ngAfterViewChecked", () {
+        it("should be true when the directive has the ngAfterViewChecked method",
             () {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewChecked,
               DirectiveImplementingAfterViewChecked)).toBe(true);
@@ -116,33 +116,33 @@ main() {
 class DirectiveNoHooks {}
 
 class DirectiveImplementingOnChanges implements OnChanges {
-  onChanges(_) {}
+  ngOnChanges(_) {}
 }
 
 class DirectiveImplementingOnCheck implements DoCheck {
-  doCheck() {}
+  ngDoCheck() {}
 }
 
 class DirectiveImplementingOnInit implements OnInit {
-  onInit() {}
+  ngOnInit() {}
 }
 
 class DirectiveImplementingOnDestroy implements OnDestroy {
-  onDestroy() {}
+  ngOnDestroy() {}
 }
 
 class DirectiveImplementingAfterContentInit implements AfterContentInit {
-  afterContentInit() {}
+  ngAfterContentInit() {}
 }
 
 class DirectiveImplementingAfterContentChecked implements AfterContentChecked {
-  afterContentChecked() {}
+  ngAfterContentChecked() {}
 }
 
 class DirectiveImplementingAfterViewInit implements AfterViewInit {
-  afterViewInit() {}
+  ngAfterViewInit() {}
 }
 
 class DirectiveImplementingAfterViewChecked implements AfterViewChecked {
-  afterViewChecked() {}
+  ngAfterViewChecked() {}
 }
diff --git a/modules/angular2/test/core/linker/directive_lifecycle_spec.ts b/modules/angular2/test/core/linker/directive_lifecycle_spec.ts
index 47f47def20..4fdc6f7b48 100644
--- a/modules/angular2/test/core/linker/directive_lifecycle_spec.ts
+++ b/modules/angular2/test/core/linker/directive_lifecycle_spec.ts
@@ -20,8 +20,8 @@ export function main() {
   describe('Create DirectiveMetadata', () => {
     describe('lifecycle', () => {
 
-      describe("onChanges", () => {
-        it("should be true when the directive has the onChanges method", () => {
+      describe("ngOnChanges", () => {
+        it("should be true when the directive has the ngOnChanges method", () => {
           expect(hasLifecycleHook(LifecycleHooks.OnChanges, DirectiveWithOnChangesMethod))
               .toBe(true);
         });
@@ -31,8 +31,8 @@ export function main() {
         });
       });
 
-      describe("onDestroy", () => {
-        it("should be true when the directive has the onDestroy method", () => {
+      describe("ngOnDestroy", () => {
+        it("should be true when the directive has the ngOnDestroy method", () => {
           expect(hasLifecycleHook(LifecycleHooks.OnDestroy, DirectiveWithOnDestroyMethod))
               .toBe(true);
         });
@@ -42,8 +42,8 @@ export function main() {
         });
       });
 
-      describe("onInit", () => {
-        it("should be true when the directive has the onInit method", () => {
+      describe("ngOnInit", () => {
+        it("should be true when the directive has the ngOnInit method", () => {
           expect(hasLifecycleHook(LifecycleHooks.OnInit, DirectiveWithOnInitMethod)).toBe(true);
         });
 
@@ -52,8 +52,8 @@ export function main() {
         });
       });
 
-      describe("doCheck", () => {
-        it("should be true when the directive has the doCheck method", () => {
+      describe("ngDoCheck", () => {
+        it("should be true when the directive has the ngDoCheck method", () => {
           expect(hasLifecycleHook(LifecycleHooks.DoCheck, DirectiveWithOnCheckMethod)).toBe(true);
         });
 
@@ -62,8 +62,8 @@ export function main() {
         });
       });
 
-      describe("afterContentInit", () => {
-        it("should be true when the directive has the afterContentInit method", () => {
+      describe("ngAfterContentInit", () => {
+        it("should be true when the directive has the ngAfterContentInit method", () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentInit,
                                   DirectiveWithAfterContentInitMethod))
               .toBe(true);
@@ -74,8 +74,8 @@ export function main() {
         });
       });
 
-      describe("afterContentChecked", () => {
-        it("should be true when the directive has the afterContentChecked method", () => {
+      describe("ngAfterContentChecked", () => {
+        it("should be true when the directive has the ngAfterContentChecked method", () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterContentChecked,
                                   DirectiveWithAfterContentCheckedMethod))
               .toBe(true);
@@ -88,8 +88,8 @@ export function main() {
       });
 
 
-      describe("afterViewInit", () => {
-        it("should be true when the directive has the afterViewInit method", () => {
+      describe("ngAfterViewInit", () => {
+        it("should be true when the directive has the ngAfterViewInit method", () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewInit, DirectiveWithAfterViewInitMethod))
               .toBe(true);
         });
@@ -99,8 +99,8 @@ export function main() {
         });
       });
 
-      describe("afterViewChecked", () => {
-        it("should be true when the directive has the afterViewChecked method", () => {
+      describe("ngAfterViewChecked", () => {
+        it("should be true when the directive has the ngAfterViewChecked method", () => {
           expect(hasLifecycleHook(LifecycleHooks.AfterViewChecked,
                                   DirectiveWithAfterViewCheckedMethod))
               .toBe(true);
@@ -117,33 +117,33 @@ export function main() {
 class DirectiveNoHooks {}
 
 class DirectiveWithOnChangesMethod {
-  onChanges(_) {}
+  ngOnChanges(_) {}
 }
 
 class DirectiveWithOnInitMethod {
-  onInit() {}
+  ngOnInit() {}
 }
 
 class DirectiveWithOnCheckMethod {
-  doCheck() {}
+  ngDoCheck() {}
 }
 
 class DirectiveWithOnDestroyMethod {
-  onDestroy() {}
+  ngOnDestroy() {}
 }
 
 class DirectiveWithAfterContentInitMethod {
-  afterContentInit() {}
+  ngAfterContentInit() {}
 }
 
 class DirectiveWithAfterContentCheckedMethod {
-  afterContentChecked() {}
+  ngAfterContentChecked() {}
 }
 
 class DirectiveWithAfterViewInitMethod {
-  afterViewInit() {}
+  ngAfterViewInit() {}
 }
 
 class DirectiveWithAfterViewCheckedMethod {
-  afterViewChecked() {}
+  ngAfterViewChecked() {}
 }
diff --git a/modules/angular2/test/core/linker/dynamic_component_loader_spec.ts b/modules/angular2/test/core/linker/dynamic_component_loader_spec.ts
index e40aae8be9..bb41755b49 100644
--- a/modules/angular2/test/core/linker/dynamic_component_loader_spec.ts
+++ b/modules/angular2/test/core/linker/dynamic_component_loader_spec.ts
@@ -283,7 +283,7 @@ class DynamicallyCreatedCmp implements OnDestroy {
     this.dynamicallyCreatedComponentService = a;
   }
 
-  onDestroy() { this.destroyed = true; }
+  ngOnDestroy() { this.destroyed = true; }
 }
 
 @Component({selector: 'dummy'})
diff --git a/modules/angular2/test/core/linker/element_injector_spec.ts b/modules/angular2/test/core/linker/element_injector_spec.ts
index 06199aee85..d6ae754170 100644
--- a/modules/angular2/test/core/linker/element_injector_spec.ts
+++ b/modules/angular2/test/core/linker/element_injector_spec.ts
@@ -218,11 +218,11 @@ class B_Needs_A {
 }
 
 class DirectiveWithDestroy implements OnDestroy {
-  onDestroyCounter: number;
+  ngOnDestroyCounter: number;
 
-  constructor() { this.onDestroyCounter = 0; }
+  constructor() { this.ngOnDestroyCounter = 0; }
 
-  onDestroy() { this.onDestroyCounter++; }
+  ngOnDestroy() { this.ngOnDestroyCounter++; }
 }
 
 export function main() {
@@ -823,14 +823,14 @@ export function main() {
         });
 
         describe("lifecycle", () => {
-          it("should call onDestroy on directives subscribed to this event", () => {
+          it("should call ngOnDestroy on directives subscribed to this event", () => {
             var inj = injector(ListWrapper.concat(
                 [DirectiveProvider.createFromType(DirectiveWithDestroy,
                                                  new DirectiveMetadata())],
                 extraProviders));
             var destroy = inj.get(DirectiveWithDestroy);
             inj.dehydrate();
-            expect(destroy.onDestroyCounter).toBe(1);
+            expect(destroy.ngOnDestroyCounter).toBe(1);
           });
 
           it("should work with services", () => {
@@ -956,7 +956,7 @@ export function main() {
               false, preBuildObjects);
 
             addInj(dummyView, inj);
-            inj.afterContentChecked();
+            inj.ngAfterContentChecked();
 
             expectDirectives(inj.get(NeedsQuery).query, CountingDirective, [0]);
           });
@@ -969,7 +969,7 @@ export function main() {
               false, preBuiltObjects);
             addInj(dummyView, inj);
 
-            inj.afterContentChecked();
+            inj.ngAfterContentChecked();
 
             expect(inj.get(NeedsTemplateRefQuery).query.first).toBe(preBuiltObjects.templateRef);
           });
@@ -985,7 +985,7 @@ export function main() {
                                false, preBuildObjects, null, dirVariableBindings);
 
             addInj(dummyView, inj);
-            inj.afterContentChecked();
+            inj.ngAfterContentChecked();
 
             expect(inj.get(NeedsQueryByVarBindings).query.first).toBe(preBuildObjects.elementRef);
           });
@@ -1003,7 +1003,7 @@ export function main() {
                                false, preBuildObjects, null, dirVariableBindings);
 
             addInj(dummyView, inj);
-            inj.afterContentChecked();
+            inj.ngAfterContentChecked();
 
             // NeedsQueryByVarBindings queries "one,two", so SimpleDirective should be before NeedsDirective
             expect(inj.get(NeedsQueryByVarBindings).query.first).toBeAnInstanceOf(SimpleDirective);
@@ -1022,7 +1022,7 @@ export function main() {
 
             addInj(dummyView, parent);
             addInj(dummyView, child);
-            parent.afterContentChecked();
+            parent.ngAfterContentChecked();
 
             expectDirectives(parent.get(NeedsQuery).query, CountingDirective, [0, 1]);
           });
diff --git a/modules/angular2/test/core/linker/integration_dart_spec.dart b/modules/angular2/test/core/linker/integration_dart_spec.dart
index 685253041f..b357fed39b 100644
--- a/modules/angular2/test/core/linker/integration_dart_spec.dart
+++ b/modules/angular2/test/core/linker/integration_dart_spec.dart
@@ -275,7 +275,7 @@ class OnChangeComponent implements OnChanges {
   String prop;
 
   @override
-  void onChanges(Map changes) {
+  void ngOnChanges(Map changes) {
     this.changes = changes;
   }
 }
@@ -305,5 +305,5 @@ class DirectiveLoggingChecks implements DoCheck {
 
   DirectiveLoggingChecks(this.log);
 
-  doCheck() => log.add("check");
+  ngDoCheck() => log.add("check");
 }
diff --git a/modules/angular2/test/core/linker/query_integration_spec.ts b/modules/angular2/test/core/linker/query_integration_spec.ts
index 8455748786..fb591feb3b 100644
--- a/modules/angular2/test/core/linker/query_integration_spec.ts
+++ b/modules/angular2/test/core/linker/query_integration_spec.ts
@@ -680,7 +680,7 @@ class NeedsContentChildren implements AfterContentInit {
   @ContentChildren(TextDirective) textDirChildren: QueryList<TextDirective>;
   numberOfChildrenAfterContentInit: number;
 
-  afterContentInit() { this.numberOfChildrenAfterContentInit = this.textDirChildren.length; }
+  ngAfterContentInit() { this.numberOfChildrenAfterContentInit = this.textDirChildren.length; }
 }
 
 @Component({selector: 'needs-view-children'})
@@ -689,7 +689,7 @@ class NeedsViewChildren implements AfterViewInit {
   @ViewChildren(TextDirective) textDirChildren: QueryList<TextDirective>;
   numberOfChildrenAfterViewInit: number;
 
-  afterViewInit() { this.numberOfChildrenAfterViewInit = this.textDirChildren.length; }
+  ngAfterViewInit() { this.numberOfChildrenAfterViewInit = this.textDirChildren.length; }
 }
 
 @Component({selector: 'needs-content-child'})
@@ -706,9 +706,9 @@ class NeedsContentChild implements AfterContentInit, AfterContentChecked {
   get child() { return this._child; }
   log = [];
 
-  afterContentInit() { this.log.push(["init", isPresent(this.child) ? this.child.text : null]); }
+  ngAfterContentInit() { this.log.push(["init", isPresent(this.child) ? this.child.text : null]); }
 
-  afterContentChecked() {
+  ngAfterContentChecked() {
     this.log.push(["check", isPresent(this.child) ? this.child.text : null]);
   }
 }
@@ -734,9 +734,9 @@ class NeedsViewChild implements AfterViewInit,
   get child() { return this._child; }
   log = [];
 
-  afterViewInit() { this.log.push(["init", isPresent(this.child) ? this.child.text : null]); }
+  ngAfterViewInit() { this.log.push(["init", isPresent(this.child) ? this.child.text : null]); }
 
-  afterViewChecked() { this.log.push(["check", isPresent(this.child) ? this.child.text : null]); }
+  ngAfterViewChecked() { this.log.push(["check", isPresent(this.child) ? this.child.text : null]); }
 }
 
 
diff --git a/modules/angular2/test/platform/browser/bootstrap_spec.ts b/modules/angular2/test/platform/browser/bootstrap_spec.ts
index 6eff80f786..f89882e322 100644
--- a/modules/angular2/test/platform/browser/bootstrap_spec.ts
+++ b/modules/angular2/test/platform/browser/bootstrap_spec.ts
@@ -76,7 +76,7 @@ class HelloOnDestroyTickCmp implements OnDestroy {
   appRef: ApplicationRef;
   constructor(@Inject(ApplicationRef) appRef) { this.appRef = appRef; }
 
-  onDestroy(): void { this.appRef.tick(); }
+  ngOnDestroy(): void { this.appRef.tick(); }
 }
 
 class _ArrayLogger {
diff --git a/modules/angular2/test/public_api_spec.ts b/modules/angular2/test/public_api_spec.ts
index db47cbbbeb..62ec7041cd 100644
--- a/modules/angular2/test/public_api_spec.ts
+++ b/modules/angular2/test/public_api_spec.ts
@@ -858,9 +858,9 @@ var NG_ALL = [
   'NG_VALUE_ACCESSOR',
   'NG_ASYNC_VALIDATORS',
   'NgClass',
-  'NgClass.doCheck()',
+  'NgClass.ngDoCheck()',
   'NgClass.initialClasses=',
-  'NgClass.onDestroy()',
+  'NgClass.ngOnDestroy()',
   'NgClass.rawClass=',
   'NgControl',
   'NgControl.control',
@@ -885,8 +885,8 @@ var NG_ALL = [
   'NgControlGroup.formDirective',
   'NgControlGroup.name',
   'NgControlGroup.name=',
-  'NgControlGroup.onDestroy()',
-  'NgControlGroup.onInit()',
+  'NgControlGroup.ngOnDestroy()',
+  'NgControlGroup.ngOnInit()',
   'NgControlGroup.path',
   'NgControlGroup.pristine',
   'NgControlGroup.touched',
@@ -911,8 +911,8 @@ var NG_ALL = [
   'NgControlName.model=',
   'NgControlName.name',
   'NgControlName.name=',
-  'NgControlName.onChanges()',
-  'NgControlName.onDestroy()',
+  'NgControlName.ngOnChanges()',
+  'NgControlName.ngOnDestroy()',
   'NgControlName.path',
   'NgControlName.pristine',
   'NgControlName.touched',
@@ -929,7 +929,7 @@ var NG_ALL = [
   'NgControlName.viewModel=',
   'NgControlName.viewToModelUpdate()',
   'NgFor',
-  'NgFor.doCheck()',
+  'NgFor.ngDoCheck()',
   'NgFor.ngForOf=',
   'NgFor.ngForTemplate=',
   'NgForm',
@@ -968,7 +968,7 @@ var NG_ALL = [
   'NgFormControl.model=',
   'NgFormControl.name',
   'NgFormControl.name=',
-  'NgFormControl.onChanges()',
+  'NgFormControl.ngOnChanges()',
   'NgFormControl.path',
   'NgFormControl.pristine',
   'NgFormControl.touched',
@@ -1001,7 +1001,7 @@ var NG_ALL = [
   'NgFormModel.name=',
   'NgFormModel.ngSubmit',
   'NgFormModel.ngSubmit=',
-  'NgFormModel.onChanges()',
+  'NgFormModel.ngOnChanges()',
   'NgFormModel.onSubmit()',
   'NgFormModel.path',
   'NgFormModel.pristine',
@@ -1022,7 +1022,7 @@ var NG_ALL = [
   'NgModel.model=',
   'NgModel.name',
   'NgModel.name=',
-  'NgModel.onChanges()',
+  'NgModel.ngOnChanges()',
   'NgModel.path',
   'NgModel.pristine',
   'NgModel.touched',
@@ -1040,7 +1040,7 @@ var NG_ALL = [
   'NgModel.viewToModelUpdate()',
   'NgSelectOption',
   'NgStyle',
-  'NgStyle.doCheck()',
+  'NgStyle.ngDoCheck()',
   'NgStyle.rawStyle=',
   'NgSwitch',
   'NgSwitch.ngSwitch=',
diff --git a/modules/angular2/test/router/integration/bootstrap_spec.ts b/modules/angular2/test/router/integration/bootstrap_spec.ts
index 22fac7e942..362a82368a 100644
--- a/modules/angular2/test/router/integration/bootstrap_spec.ts
+++ b/modules/angular2/test/router/integration/bootstrap_spec.ts
@@ -274,7 +274,7 @@ class AppWithViewChildren implements AfterViewInit {
 
   constructor(public router: Router, public location: LocationStrategy) {}
 
-  afterViewInit() { this.helloCmp.message = 'Ahoy'; }
+  ngAfterViewInit() { this.helloCmp.message = 'Ahoy'; }
 }
 
 @Component({
diff --git a/modules/angular2/test/router/integration/lifecycle_hook_spec.ts b/modules/angular2/test/router/integration/lifecycle_hook_spec.ts
index 5130f2c090..207ff02289 100644
--- a/modules/angular2/test/router/integration/lifecycle_hook_spec.ts
+++ b/modules/angular2/test/router/integration/lifecycle_hook_spec.ts
@@ -69,7 +69,7 @@ export function main() {
       eventBus = new EventEmitter();
     }));
 
-    it('should call the onActivate hook', inject([AsyncTestCompleter], (async) => {
+    it('should call the routerOnActivate hook', inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -82,7 +82,7 @@ export function main() {
              });
        }));
 
-    it('should wait for a parent component\'s onActivate hook to resolve before calling its child\'s',
+    it('should wait for a parent component\'s routerOnActivate hook to resolve before calling its child\'s',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -106,7 +106,7 @@ export function main() {
              });
        }));
 
-    it('should call the onDeactivate hook', inject([AsyncTestCompleter], (async) => {
+    it('should call the routerOnDeactivate hook', inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
@@ -120,7 +120,7 @@ export function main() {
              });
        }));
 
-    it('should wait for a child component\'s onDeactivate hook to resolve before calling its parent\'s',
+    it('should wait for a child component\'s routerOnDeactivate hook to resolve before calling its parent\'s',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -146,7 +146,7 @@ export function main() {
              });
        }));
 
-    it('should reuse a component when the canReuse hook returns true',
+    it('should reuse a component when the routerCanReuse hook returns true',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -169,7 +169,7 @@ export function main() {
        }));
 
 
-    it('should not reuse a component when the canReuse hook returns false',
+    it('should not reuse a component when the routerCanReuse hook returns false',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -192,34 +192,35 @@ export function main() {
        }));
 
 
-    it('should navigate when canActivate returns true', inject([AsyncTestCompleter], (async) => {
-         compile(tcb)
-             .then((rtc) => {fixture = rtc})
-             .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
-             .then((_) => {
-               ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canActivate')) {
-                   completer.resolve(true);
-                 }
-               });
-               rtr.navigateByUrl('/can-activate/a')
-                   .then((_) => {
-                     fixture.detectChanges();
-                     expect(fixture.debugElement.nativeElement).toHaveText('canActivate {A}');
-                     expect(log).toEqual(['canActivate: null -> /can-activate']);
-                     async.done();
-                   });
-             });
-       }));
-
-    it('should not navigate when canActivate returns false',
+    it('should navigate when routerCanActivate returns true',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
              .then((_) => {
                ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canActivate')) {
+                 if (ev.startsWith('routerCanActivate')) {
+                   completer.resolve(true);
+                 }
+               });
+               rtr.navigateByUrl('/can-activate/a')
+                   .then((_) => {
+                     fixture.detectChanges();
+                     expect(fixture.debugElement.nativeElement).toHaveText('routerCanActivate {A}');
+                     expect(log).toEqual(['routerCanActivate: null -> /can-activate']);
+                     async.done();
+                   });
+             });
+       }));
+
+    it('should not navigate when routerCanActivate returns false',
+       inject([AsyncTestCompleter], (async) => {
+         compile(tcb)
+             .then((rtc) => {fixture = rtc})
+             .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
+             .then((_) => {
+               ObservableWrapper.subscribe<string>(eventBus, (ev) => {
+                 if (ev.startsWith('routerCanActivate')) {
                    completer.resolve(false);
                  }
                });
@@ -227,13 +228,13 @@ export function main() {
                    .then((_) => {
                      fixture.detectChanges();
                      expect(fixture.debugElement.nativeElement).toHaveText('');
-                     expect(log).toEqual(['canActivate: null -> /can-activate']);
+                     expect(log).toEqual(['routerCanActivate: null -> /can-activate']);
                      async.done();
                    });
              });
        }));
 
-    it('should navigate away when canDeactivate returns true',
+    it('should navigate away when routerCanDeactivate returns true',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -241,11 +242,11 @@ export function main() {
              .then((_) => rtr.navigateByUrl('/can-deactivate/a'))
              .then((_) => {
                fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('canDeactivate {A}');
+               expect(fixture.debugElement.nativeElement).toHaveText('routerCanDeactivate {A}');
                expect(log).toEqual([]);
 
                ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canDeactivate')) {
+                 if (ev.startsWith('routerCanDeactivate')) {
                    completer.resolve(true);
                  }
                });
@@ -253,13 +254,13 @@ export function main() {
                rtr.navigateByUrl('/a').then((_) => {
                  fixture.detectChanges();
                  expect(fixture.debugElement.nativeElement).toHaveText('A');
-                 expect(log).toEqual(['canDeactivate: /can-deactivate -> /a']);
+                 expect(log).toEqual(['routerCanDeactivate: /can-deactivate -> /a']);
                  async.done();
                });
              });
        }));
 
-    it('should not navigate away when canDeactivate returns false',
+    it('should not navigate away when routerCanDeactivate returns false',
        inject([AsyncTestCompleter], (async) => {
          compile(tcb)
              .then((rtc) => {fixture = rtc})
@@ -267,19 +268,19 @@ export function main() {
              .then((_) => rtr.navigateByUrl('/can-deactivate/a'))
              .then((_) => {
                fixture.detectChanges();
-               expect(fixture.debugElement.nativeElement).toHaveText('canDeactivate {A}');
+               expect(fixture.debugElement.nativeElement).toHaveText('routerCanDeactivate {A}');
                expect(log).toEqual([]);
 
                ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canDeactivate')) {
+                 if (ev.startsWith('routerCanDeactivate')) {
                    completer.resolve(false);
                  }
                });
 
                rtr.navigateByUrl('/a').then((_) => {
                  fixture.detectChanges();
-                 expect(fixture.debugElement.nativeElement).toHaveText('canDeactivate {A}');
-                 expect(log).toEqual(['canDeactivate: /can-deactivate -> /a']);
+                 expect(fixture.debugElement.nativeElement).toHaveText('routerCanDeactivate {A}');
+                 expect(log).toEqual(['routerCanDeactivate: /can-deactivate -> /a']);
                  async.done();
                });
              });
@@ -294,10 +295,10 @@ export function main() {
              .then((_) => rtr.navigateByUrl('/activation-hooks/child'))
              .then((_) => {
                expect(log).toEqual([
-                 'canActivate child: null -> /child',
-                 'canActivate parent: null -> /activation-hooks',
-                 'onActivate parent: null -> /activation-hooks',
-                 'onActivate child: null -> /child'
+                 'routerCanActivate child: null -> /child',
+                 'routerCanActivate parent: null -> /activation-hooks',
+                 'routerOnActivate parent: null -> /activation-hooks',
+                 'routerOnActivate child: null -> /child'
                ]);
 
                log = [];
@@ -305,10 +306,10 @@ export function main() {
              })
              .then((_) => {
                expect(log).toEqual([
-                 'canDeactivate parent: /activation-hooks -> /a',
-                 'canDeactivate child: /child -> null',
-                 'onDeactivate child: /child -> null',
-                 'onDeactivate parent: /activation-hooks -> /a'
+                 'routerCanDeactivate parent: /activation-hooks -> /a',
+                 'routerCanDeactivate child: /child -> null',
+                 'routerOnDeactivate child: /child -> null',
+                 'routerOnDeactivate parent: /activation-hooks -> /a'
                ]);
                async.done();
              });
@@ -320,11 +321,13 @@ export function main() {
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
              .then((_) => rtr.navigateByUrl('/reuse-hooks/1'))
              .then((_) => {
-               expect(log).toEqual(
-                   ['canActivate: null -> /reuse-hooks/1', 'onActivate: null -> /reuse-hooks/1']);
+               expect(log).toEqual([
+                 'routerCanActivate: null -> /reuse-hooks/1',
+                 'routerOnActivate: null -> /reuse-hooks/1'
+               ]);
 
                ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canReuse')) {
+                 if (ev.startsWith('routerCanReuse')) {
                    completer.resolve(true);
                  }
                });
@@ -335,8 +338,8 @@ export function main() {
              })
              .then((_) => {
                expect(log).toEqual([
-                 'canReuse: /reuse-hooks/1 -> /reuse-hooks/2',
-                 'onReuse: /reuse-hooks/1 -> /reuse-hooks/2'
+                 'routerCanReuse: /reuse-hooks/1 -> /reuse-hooks/2',
+                 'routerOnReuse: /reuse-hooks/1 -> /reuse-hooks/2'
                ]);
                async.done();
              });
@@ -347,11 +350,13 @@ export function main() {
              .then((_) => rtr.config([new Route({path: '/...', component: LifecycleCmp})]))
              .then((_) => rtr.navigateByUrl('/reuse-hooks/1'))
              .then((_) => {
-               expect(log).toEqual(
-                   ['canActivate: null -> /reuse-hooks/1', 'onActivate: null -> /reuse-hooks/1']);
+               expect(log).toEqual([
+                 'routerCanActivate: null -> /reuse-hooks/1',
+                 'routerOnActivate: null -> /reuse-hooks/1'
+               ]);
 
                ObservableWrapper.subscribe<string>(eventBus, (ev) => {
-                 if (ev.startsWith('canReuse')) {
+                 if (ev.startsWith('routerCanReuse')) {
                    completer.resolve(false);
                  }
                });
@@ -361,11 +366,11 @@ export function main() {
              })
              .then((_) => {
                expect(log).toEqual([
-                 'canReuse: /reuse-hooks/1 -> /reuse-hooks/2',
-                 'canActivate: /reuse-hooks/1 -> /reuse-hooks/2',
-                 'canDeactivate: /reuse-hooks/1 -> /reuse-hooks/2',
-                 'onDeactivate: /reuse-hooks/1 -> /reuse-hooks/2',
-                 'onActivate: /reuse-hooks/1 -> /reuse-hooks/2'
+                 'routerCanReuse: /reuse-hooks/1 -> /reuse-hooks/2',
+                 'routerCanActivate: /reuse-hooks/1 -> /reuse-hooks/2',
+                 'routerCanDeactivate: /reuse-hooks/1 -> /reuse-hooks/2',
+                 'routerOnDeactivate: /reuse-hooks/1 -> /reuse-hooks/2',
+                 'routerOnActivate: /reuse-hooks/1 -> /reuse-hooks/2'
                ]);
                async.done();
              });
@@ -393,7 +398,7 @@ function logHook(name: string, next: ComponentInstruction, prev: ComponentInstru
 
 @Component({selector: 'activate-cmp', template: 'activate cmp'})
 class ActivateCmp implements OnActivate {
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
     logHook('activate', next, prev);
   }
 }
@@ -405,7 +410,7 @@ class ActivateCmp implements OnActivate {
 })
 @RouteConfig([new Route({path: '/child-activate', component: ActivateCmp})])
 class ParentActivateCmp implements OnActivate {
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
     completer = PromiseWrapper.completer();
     logHook('parent activate', next, prev);
     return completer.promise;
@@ -414,14 +419,14 @@ class ParentActivateCmp implements OnActivate {
 
 @Component({selector: 'deactivate-cmp', template: 'deactivate cmp'})
 class DeactivateCmp implements OnDeactivate {
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
     logHook('deactivate', next, prev);
   }
 }
 
 @Component({selector: 'deactivate-cmp', template: 'deactivate cmp'})
 class WaitDeactivateCmp implements OnDeactivate {
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
     completer = PromiseWrapper.completer();
     logHook('deactivate', next, prev);
     return completer.promise;
@@ -435,7 +440,7 @@ class WaitDeactivateCmp implements OnDeactivate {
 })
 @RouteConfig([new Route({path: '/child-deactivate', component: WaitDeactivateCmp})])
 class ParentDeactivateCmp implements OnDeactivate {
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
     logHook('parent deactivate', next, prev);
   }
 }
@@ -449,8 +454,10 @@ class ParentDeactivateCmp implements OnDeactivate {
 class ReuseCmp implements OnReuse,
     CanReuse {
   constructor() { cmpInstanceCount += 1; }
-  canReuse(next: ComponentInstruction, prev: ComponentInstruction) { return true; }
-  onReuse(next: ComponentInstruction, prev: ComponentInstruction) { logHook('reuse', next, prev); }
+  routerCanReuse(next: ComponentInstruction, prev: ComponentInstruction) { return true; }
+  routerOnReuse(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('reuse', next, prev);
+  }
 }
 
 @Component({
@@ -462,58 +469,61 @@ class ReuseCmp implements OnReuse,
 class NeverReuseCmp implements OnReuse,
     CanReuse {
   constructor() { cmpInstanceCount += 1; }
-  canReuse(next: ComponentInstruction, prev: ComponentInstruction) { return false; }
-  onReuse(next: ComponentInstruction, prev: ComponentInstruction) { logHook('reuse', next, prev); }
+  routerCanReuse(next: ComponentInstruction, prev: ComponentInstruction) { return false; }
+  routerOnReuse(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('reuse', next, prev);
+  }
 }
 
 @Component({
   selector: 'can-activate-cmp',
-  template: `canActivate {<router-outlet></router-outlet>}`,
+  template: `routerCanActivate {<router-outlet></router-outlet>}`,
   directives: [RouterOutlet]
 })
 @RouteConfig([new Route({path: '/a', component: A}), new Route({path: '/b', component: B})])
-@CanActivate(CanActivateCmp.canActivate)
+@CanActivate(CanActivateCmp.routerCanActivate)
 class CanActivateCmp {
-  static canActivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<boolean> {
+  static routerCanActivate(next: ComponentInstruction,
+                           prev: ComponentInstruction): Promise<boolean> {
     completer = PromiseWrapper.completer();
-    logHook('canActivate', next, prev);
+    logHook('routerCanActivate', next, prev);
     return completer.promise;
   }
 }
 
 @Component({
   selector: 'can-deactivate-cmp',
-  template: `canDeactivate {<router-outlet></router-outlet>}`,
+  template: `routerCanDeactivate {<router-outlet></router-outlet>}`,
   directives: [RouterOutlet]
 })
 @RouteConfig([new Route({path: '/a', component: A}), new Route({path: '/b', component: B})])
 class CanDeactivateCmp implements CanDeactivate {
-  canDeactivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<boolean> {
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<boolean> {
     completer = PromiseWrapper.completer();
-    logHook('canDeactivate', next, prev);
+    logHook('routerCanDeactivate', next, prev);
     return completer.promise;
   }
 }
 
 @Component({selector: 'all-hooks-child-cmp', template: `child`})
-@CanActivate(AllHooksChildCmp.canActivate)
+@CanActivate(AllHooksChildCmp.routerCanActivate)
 class AllHooksChildCmp implements CanDeactivate, OnDeactivate, OnActivate {
-  canDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canDeactivate child', next, prev);
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanDeactivate child', next, prev);
     return true;
   }
 
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onDeactivate child', next, prev);
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnDeactivate child', next, prev);
   }
 
-  static canActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canActivate child', next, prev);
+  static routerCanActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanActivate child', next, prev);
     return true;
   }
 
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onActivate child', next, prev);
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnActivate child', next, prev);
   }
 }
 
@@ -523,57 +533,57 @@ class AllHooksChildCmp implements CanDeactivate, OnDeactivate, OnActivate {
   directives: [RouterOutlet]
 })
 @RouteConfig([new Route({path: '/child', component: AllHooksChildCmp})])
-@CanActivate(AllHooksParentCmp.canActivate)
+@CanActivate(AllHooksParentCmp.routerCanActivate)
 class AllHooksParentCmp implements CanDeactivate,
     OnDeactivate, OnActivate {
-  canDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canDeactivate parent', next, prev);
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanDeactivate parent', next, prev);
     return true;
   }
 
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onDeactivate parent', next, prev);
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnDeactivate parent', next, prev);
   }
 
-  static canActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canActivate parent', next, prev);
+  static routerCanActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanActivate parent', next, prev);
     return true;
   }
 
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onActivate parent', next, prev);
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnActivate parent', next, prev);
   }
 }
 
 @Component({selector: 'reuse-hooks-cmp', template: 'reuse hooks cmp'})
-@CanActivate(ReuseHooksCmp.canActivate)
+@CanActivate(ReuseHooksCmp.routerCanActivate)
 class ReuseHooksCmp implements OnActivate, OnReuse, OnDeactivate, CanReuse, CanDeactivate {
-  canReuse(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
+  routerCanReuse(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
     completer = PromiseWrapper.completer();
-    logHook('canReuse', next, prev);
+    logHook('routerCanReuse', next, prev);
     return completer.promise;
   }
 
-  onReuse(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onReuse', next, prev);
+  routerOnReuse(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnReuse', next, prev);
   }
 
-  canDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canDeactivate', next, prev);
+  routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanDeactivate', next, prev);
     return true;
   }
 
-  onDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onDeactivate', next, prev);
+  routerOnDeactivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnDeactivate', next, prev);
   }
 
-  static canActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('canActivate', next, prev);
+  static routerCanActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerCanActivate', next, prev);
     return true;
   }
 
-  onActivate(next: ComponentInstruction, prev: ComponentInstruction) {
-    logHook('onActivate', next, prev);
+  routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction) {
+    logHook('routerOnActivate', next, prev);
   }
 }
 
diff --git a/modules/angular2/test/router/router_spec.ts b/modules/angular2/test/router/router_spec.ts
index af3190e623..335218fdd1 100644
--- a/modules/angular2/test/router/router_spec.ts
+++ b/modules/angular2/test/router/router_spec.ts
@@ -238,8 +238,8 @@ class DummyParentComp {
 function makeDummyOutlet() {
   var ref = new SpyRouterOutlet();
   ref.spy('canActivate').andCallFake((_) => PromiseWrapper.resolve(true));
-  ref.spy('canReuse').andCallFake((_) => PromiseWrapper.resolve(false));
-  ref.spy('canDeactivate').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));
   return ref;
 }
diff --git a/modules/angular2/test/upgrade/upgrade_spec.ts b/modules/angular2/test/upgrade/upgrade_spec.ts
index 05f53fc456..2eefd3cbe0 100644
--- a/modules/angular2/test/upgrade/upgrade_spec.ts
+++ b/modules/angular2/test/upgrade/upgrade_spec.ts
@@ -131,11 +131,11 @@ export function main() {
                  template: "ignore: {{ignore}}; " +
                                "literal: {{literal}}; interpolate: {{interpolate}}; " +
                                "oneWayA: {{oneWayA}}; oneWayB: {{oneWayB}}; " +
-                               "twoWayA: {{twoWayA}}; twoWayB: {{twoWayB}}; ({{onChangesCount}})"
+                               "twoWayA: {{twoWayA}}; twoWayB: {{twoWayB}}; ({{ngOnChangesCount}})"
                })
                    .Class({
                      constructor: function() {
-                       this.onChangesCount = 0;
+                       this.ngOnChangesCount = 0;
                        this.ignore = '-';
                        this.literal = '?';
                        this.interpolate = '?';
@@ -148,7 +148,7 @@ export function main() {
                        this.twoWayAEmitter = new EventEmitter();
                        this.twoWayBEmitter = new EventEmitter();
                      },
-                     onChanges: function(changes) {
+                     ngOnChanges: function(changes) {
                        var assert = (prop, value) => {
                          if (this[prop] != value) {
                            throw new Error(
@@ -168,7 +168,7 @@ export function main() {
                          }
                        };
 
-                       switch (this.onChangesCount++) {
+                       switch (this.ngOnChangesCount++) {
                          case 0:
                            assert('ignore', '-');
                            assertChange('literal', 'Text');
diff --git a/modules/angular2_material/src/components/button/button.ts b/modules/angular2_material/src/components/button/button.ts
index acd8786303..b7169b1005 100644
--- a/modules/angular2_material/src/components/button/button.ts
+++ b/modules/angular2_material/src/components/button/button.ts
@@ -85,7 +85,7 @@ export class MdAnchor extends MdButton implements OnChanges {
   }
 
   /** Invoked when a change is detected. */
-  onChanges(_) {
+  ngOnChanges(_) {
     // A disabled anchor should not be in the tab flow.
     this.tabIndex = this.disabled ? -1 : 0;
   }
diff --git a/modules/angular2_material/src/components/grid_list/grid_list.ts b/modules/angular2_material/src/components/grid_list/grid_list.ts
index 1f7b57b89d..8dff96214b 100644
--- a/modules/angular2_material/src/components/grid_list/grid_list.ts
+++ b/modules/angular2_material/src/components/grid_list/grid_list.ts
@@ -86,7 +86,7 @@ export class MdGridList implements AfterContentChecked {
     }
   }
 
-  afterContentChecked() {
+  ngAfterContentChecked() {
     this.layoutTiles();
   }
 
@@ -267,7 +267,7 @@ export class MdGridTile implements OnDestroy,
    * Change handler invoked when bindings are resolved or when bindings have changed.
    * Notifies grid-list that a re-layout is required.
    */
-  onChanges(_) {
+  ngOnChanges(_) {
     if (!this.isRegisteredWithGridList) {
       this.gridList.addTile(this);
       this.isRegisteredWithGridList = true;
@@ -277,7 +277,7 @@ export class MdGridTile implements OnDestroy,
   /**
    * Destructor function. Deregisters this tile from the containing grid-list.
    */
-  onDestroy() {
+  ngOnDestroy() {
     this.gridList.removeTile(this);
   }
 }
diff --git a/modules/angular2_material/src/components/input/input.ts b/modules/angular2_material/src/components/input/input.ts
index e4dab257da..84cee596b4 100644
--- a/modules/angular2_material/src/components/input/input.ts
+++ b/modules/angular2_material/src/components/input/input.ts
@@ -30,7 +30,7 @@ export class MdInputContainer implements AfterContentChecked {
     this.inputHasFocus = false;
   }
 
-  afterContentChecked() {
+  ngAfterContentChecked() {
     // Enforce that this directive actually contains a text input.
     if (this._input == null) {
       throw 'No <input> or <textarea> found inside of <md-input-container>';
diff --git a/modules/angular2_material/src/components/progress-linear/progress_linear.ts b/modules/angular2_material/src/components/progress-linear/progress_linear.ts
index dfbf4bb729..ac9ec251b1 100644
--- a/modules/angular2_material/src/components/progress-linear/progress_linear.ts
+++ b/modules/angular2_material/src/components/progress-linear/progress_linear.ts
@@ -60,7 +60,7 @@ export class MdProgressLinear implements OnChanges {
     }
   }
 
-  onChanges(_) {
+  ngOnChanges(_) {
     // If the mode does not use a value, or if there is no value, do nothing.
     if (this.mode == ProgressMode.QUERY || this.mode == ProgressMode.INDETERMINATE ||
         isBlank(this.value)) {
diff --git a/modules/angular2_material/src/components/radio/radio_button.ts b/modules/angular2_material/src/components/radio/radio_button.ts
index f7729bd697..11f2673417 100644
--- a/modules/angular2_material/src/components/radio/radio_button.ts
+++ b/modules/angular2_material/src/components/radio/radio_button.ts
@@ -102,7 +102,7 @@ export class MdRadioGroup implements OnChanges {
   }
 
   /** Change handler invoked when bindings are resolved or when bindings have changed. */
-  onChanges(_) {
+  ngOnChanges(_) {
     // If the component has a disabled attribute with no value, it will set disabled = ''.
     this.disabled = isPresent(this.disabled) && this.disabled !== false;
 
@@ -263,7 +263,7 @@ export class MdRadioButton implements OnInit {
   }
 
   /** Change handler invoked when bindings are resolved or when bindings have changed. */
-  onInit() {
+  ngOnInit() {
     if (isPresent(this.radioGroup)) {
       this.name = this.radioGroup.getName();
     }
diff --git a/modules_dart/transform/lib/src/transform/template_compiler/change_detector_codegen.dart b/modules_dart/transform/lib/src/transform/template_compiler/change_detector_codegen.dart
index 0e6364b2e6..99c818536a 100644
--- a/modules_dart/transform/lib/src/transform/template_compiler/change_detector_codegen.dart
+++ b/modules_dart/transform/lib/src/transform/template_compiler/change_detector_codegen.dart
@@ -545,20 +545,20 @@ class _CodegenState {
   String _genDoCheck(ProtoRecord r) {
     var br = r.bindingRecord;
     return 'if (!throwOnChange) '
-        '${_names.getDirectiveName(br.directiveRecord.directiveIndex)}.doCheck();';
+        '${_names.getDirectiveName(br.directiveRecord.directiveIndex)}.ngDoCheck();';
   }
 
   String _genOnInit(ProtoRecord r) {
     var br = r.bindingRecord;
     return 'if (!throwOnChange && ${_names.getStateName()} == ${_genPrefix}$_STATE.NeverChecked) '
-        '${_names.getDirectiveName(br.directiveRecord.directiveIndex)}.onInit();';
+        '${_names.getDirectiveName(br.directiveRecord.directiveIndex)}.ngOnInit();';
   }
 
   String _genOnChanges(ProtoRecord r) {
     var br = r.bindingRecord;
     return 'if (!throwOnChange && $_CHANGES_LOCAL != null) '
         '${_names.getDirectiveName(br.directiveRecord.directiveIndex)}'
-        '.onChanges($_CHANGES_LOCAL);';
+        '.ngOnChanges($_CHANGES_LOCAL);';
   }
 
   String _genNotifyOnPushDetectors(ProtoRecord r) {