feat(pipes): changed PipeTransform to make onDestroy optional

BREAKING CHANGE:

Before:
  Angular called onDestroy on all pipes.

After:
  Angular calls onDestroy only on pipes that have the onDestroy method.

Author: vsavkin

modules/angular2/src/change_detection/change_detection.ts

@@ -44,7 +44,7 @@ export {DynamicChangeDetector} from './dynamic_change_detector';
 export {ChangeDetectorRef} from './change_detector_ref';
 export {IterableDiffers, IterableDiffer, IterableDifferFactory} from './differs/iterable_differs';
 export {KeyValueDiffers, KeyValueDiffer, KeyValueDifferFactory} from './differs/keyvalue_differs';
-export {PipeTransform, BasePipeTransform} from './pipe_transform';
+export {PipeTransform, PipeOnDestroy, BasePipeTransform} from './pipe_transform';
 export {WrappedValue} from './change_detection_util';
 
 /**

modules/angular2/src/change_detection/change_detection_util.ts

@@ -2,6 +2,7 @@ import {CONST_EXPR, isPresent, isBlank, BaseException, Type} from 'angular2/src/
 import {List, ListWrapper, MapWrapper, StringMapWrapper} from 'angular2/src/facade/collection';
 import {ProtoRecord} from './proto_record';
 import {CHECK_ALWAYS, CHECK_ONCE, CHECKED, DETACHED, ON_PUSH} from './constants';
+import {implementsOnDestroy} from './pipe_lifecycle_reflector';
 
 
 /**
@@ -180,4 +181,10 @@ export class ChangeDetectionUtil {
                null :
                protos[selfIndex - 1];  // self index is shifted by one because of context
   }
+
+  static callPipeOnDestroy(pipe: any): void {
+    if (implementsOnDestroy(pipe)) {
+      pipe.onDestroy();
+    }
+  }
 }

modules/angular2/src/change_detection/codegen_name_util.ts

@@ -146,9 +146,13 @@ export class CodegenNameUtil {
    * Generates statements destroying all pipe variables.
    */
   genPipeOnDestroy(): string {
-    return ListWrapper.join(ListWrapper.map(ListWrapper.filter(this.records, (r) => {
-      return r.isPipeRecord();
-    }), (r) => { return `${this.getPipeName(r.selfIndex)}.onDestroy();`; }), '\n');
+    return ListWrapper.join(
+        ListWrapper.map(
+            ListWrapper.filter(this.records, (r) => { return r.isPipeRecord(); }),
+            (r) => {
+              return `${this.utilName}.callPipeOnDestroy(${this.getPipeName(r.selfIndex)});`;
+            }),
+        '\n');
   }
 
   getPipeName(idx: int): string {

modules/angular2/src/change_detection/dynamic_change_detector.ts

@@ -48,7 +48,7 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
   _destroyPipes() {
     for (var i = 0; i < this.localPipes.length; ++i) {
       if (isPresent(this.localPipes[i])) {
-        this.localPipes[i].onDestroy();
+        ChangeDetectionUtil.callPipeOnDestroy(this.localPipes[i]);
       }
     }
   }

modules/angular2/src/change_detection/pipe_lifecycle_reflector.dart

@@ -0,0 +1,5 @@
+library angular2.core.compiler.pipe_lifecycle_reflector;
+
+import 'package:angular2/src/change_detection/pipe_transform.dart';
+
+bool implementsOnDestroy(Object pipe) => pipe is PipeOnDestroy;

modules/angular2/src/change_detection/pipe_lifecycle_reflector.ts

@@ -0,0 +1,3 @@
+export function implementsOnDestroy(pipe: any): boolean {
+  return pipe.constructor.prototype.onDestroy;
+}

modules/angular2/src/change_detection/pipe_transform.ts

@@ -7,19 +7,36 @@ import {ABSTRACT, BaseException, CONST, Type} from 'angular2/src/facade/lang';
  *
  * ```
  * class DoublePipe implements PipeTransform {
- *  onDestroy() {}
- *
  *  transform(value, args = []) {
  *    return `${value}${value}`;
  *  }
  * }
  * ```
  */
-export interface PipeTransform {
-  onDestroy(): void;
+export interface PipeTransform { transform(value: any, args: List<any>): any; }
 
-  transform(value: any, args: List<any>): any;
-}
+/**
+ * An interface that stateful pipes should implement.
+ *
+ * #Example
+ *
+ * ```
+ * class StatefulPipe implements PipeTransform, PipeOnDestroy {
+ *  connection;
+ *
+ *  onDestroy() {
+ *    this.connection.release();
+ *  }
+ *
+ *  transform(value, args = []) {
+ *    this.connection = createConnection();
+ *    // ...
+ *    return someValue;
+ *  }
+ * }
+ * ```
+ */
+export interface PipeOnDestroy { onDestroy(): void; }
 
 /**
  * Provides default implementation of the `onDestroy` method.
@@ -35,7 +52,7 @@ export interface PipeTransform {
  * ```
  */
 @CONST()
-export class BasePipeTransform implements PipeTransform {
+export class BasePipeTransform implements PipeTransform, PipeOnDestroy {
   onDestroy(): void {}
   transform(value: any, args: List<any>): any { return _abstract(); }
 }

modules/angular2/test/change_detection/change_detector_spec.ts

@@ -30,6 +30,7 @@ import {
   DirectiveRecord,
   DirectiveIndex,
   PipeTransform,
+  PipeOnDestroy,
   CHECK_ALWAYS,
   CHECK_ONCE,
   CHECKED,
@@ -768,7 +769,7 @@ export function main() {
           expect(cd.hydrated()).toBe(true);
         });
 
-        it('should destroy all active pipes during dehyration', () => {
+        it('should destroy all active pipes implementing onDestroy during dehyration', () => {
           var pipe = new PipeWithOnDestroy();
           var registry = new FakePipes('pipe', () => pipe);
           var cd = _createChangeDetector('name | pipe', new Person('bob'), registry).changeDetector;
@@ -779,6 +780,15 @@ export function main() {
           expect(pipe.destroyCalled).toBe(true);
         });
 
+        it('should not call onDestroy all pipes that do not implement onDestroy', () => {
+          var pipe = new CountingPipe();
+          var registry = new FakePipes('pipe', () => pipe);
+          var cd = _createChangeDetector('name | pipe', new Person('bob'), registry).changeDetector;
+
+          cd.detectChanges();
+          expect(() => cd.dehydrate()).not.toThrow();
+        });
+
         it('should throw when detectChanges is called on a dehydrated detector', () => {
           var context = new Person('Bob');
           var val = _createChangeDetector('name', context);
@@ -844,24 +854,21 @@ export function main() {
 
 class CountingPipe implements PipeTransform {
   state: number = 0;
-  onDestroy() {}
   transform(value, args = null) { return `${value} state:${this.state ++}`; }
 }
 
-class PipeWithOnDestroy implements PipeTransform {
+class PipeWithOnDestroy implements PipeTransform, PipeOnDestroy {
   destroyCalled: boolean = false;
   onDestroy() { this.destroyCalled = true; }
 
   transform(value, args = null) { return null; }
 }
 
 class IdentityPipe implements PipeTransform {
-  onDestroy() {}
   transform(value, args = null) { return value; }
 }
 
 class WrappedPipe implements PipeTransform {
-  onDestroy() {}
   transform(value, args = null) { return WrappedValue.wrap(value); }
 }
 
@@ -872,7 +879,6 @@ class MultiArgPipe implements PipeTransform {
     var arg3 = args.length > 2 ? args[2] : 'default';
     return `${value} ${arg1} ${arg2} ${arg3}`;
   }
-  onDestroy(): void {}
 }
 
 class FakePipes implements Pipes {