fix(compiler): properly implement pure pipes and change pipe syntax

Pure pipes as well as arrays and maps are
implemented via proxy functions. This is
faster than the previous implementation
and also generates less code.

BREAKING CHANGE:
- pipes now take a variable number of arguments, and not an array that contains all arguments.

Author: tbosch

modules/angular2/src/common/pipes/async_pipe.ts

@@ -1,13 +1,6 @@
 import {isBlank, isPresent, isPromise, CONST} from 'angular2/src/facade/lang';
 import {ObservableWrapper, Observable, EventEmitter} from 'angular2/src/facade/async';
-import {
-  Pipe,
-  Injectable,
-  ChangeDetectorRef,
-  OnDestroy,
-  PipeTransform,
-  WrappedValue
-} from 'angular2/core';
+import {Pipe, Injectable, ChangeDetectorRef, OnDestroy, WrappedValue} from 'angular2/core';
 
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -55,7 +48,7 @@ var __unused: Promise<any>;  // avoid unused import when Promise union types are
  */
 @Pipe({name: 'async', pure: false})
 @Injectable()
-export class AsyncPipe implements PipeTransform, OnDestroy {
+export class AsyncPipe implements OnDestroy {
   /** @internal */
   _latestValue: Object = null;
   /** @internal */
@@ -76,7 +69,7 @@ export class AsyncPipe implements PipeTransform, OnDestroy {
     }
   }
 
-  transform(obj: Observable<any>| Promise<any>| EventEmitter<any>, args?: any[]): any {
+  transform(obj: Observable<any>| Promise<any>| EventEmitter<any>): any {
     if (isBlank(this._obj)) {
       if (isPresent(obj)) {
         this._subscribe(obj);

modules/angular2/src/common/pipes/date_pipe.ts

@@ -101,14 +101,13 @@ export class DatePipe implements PipeTransform {
   };
 
 
-  transform(value: any, args: any[]): string {
+  transform(value: any, pattern: string = 'mediumDate'): string {
     if (isBlank(value)) return null;
 
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentException(DatePipe, value);
     }
 
-    var pattern: string = isPresent(args) && args.length > 0 ? args[0] : 'mediumDate';
     if (isNumber(value)) {
       value = DateWrapper.fromMillis(value);
     }

modules/angular2/src/common/pipes/i18n_plural_pipe.ts

@@ -45,10 +45,9 @@ var interpolationExp: RegExp = RegExpWrapper.create('#');
 @Pipe({name: 'i18nPlural', pure: true})
 @Injectable()
 export class I18nPluralPipe implements PipeTransform {
-  transform(value: number, args: any[] = null): string {
+  transform(value: number, pluralMap: {[count: string]: string}): string {
     var key: string;
     var valueStr: string;
-    var pluralMap: {[count: string]: string} = <{[count: string]: string}>(args[0]);
 
     if (!isStringMap(pluralMap)) {
       throw new InvalidPipeArgumentException(I18nPluralPipe, pluralMap);

modules/angular2/src/common/pipes/i18n_select_pipe.ts

@@ -36,8 +36,7 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @Pipe({name: 'i18nSelect', pure: true})
 @Injectable()
 export class I18nSelectPipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
-    var mapping: {[key: string]: string} = <{[count: string]: string}>(args[0]);
+  transform(value: string, mapping: {[key: string]: string}): string {
     if (!isStringMap(mapping)) {
       throw new InvalidPipeArgumentException(I18nSelectPipe, mapping);
     }

modules/angular2/src/common/pipes/json_pipe.ts

@@ -11,5 +11,5 @@ import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
 @Pipe({name: 'json', pure: false})
 @Injectable()
 export class JsonPipe implements PipeTransform {
-  transform(value: any, args: any[] = null): string { return Json.stringify(value); }
+  transform(value: any): string { return Json.stringify(value); }
 }

modules/angular2/src/common/pipes/lowercase_pipe.ts

@@ -13,7 +13,7 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @Pipe({name: 'lowercase'})
 @Injectable()
 export class LowerCasePipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
+  transform(value: string): string {
     if (isBlank(value)) return value;
     if (!isString(value)) {
       throw new InvalidPipeArgumentException(LowerCasePipe, value);

modules/angular2/src/common/pipes/number_pipe.ts

@@ -11,7 +11,6 @@ import {
 import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
 import {NumberFormatter, NumberFormatStyle} from 'angular2/src/facade/intl';
 import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
-import {ListWrapper} from 'angular2/src/facade/collection';
 
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -87,8 +86,7 @@ export class NumberPipe {
 @Pipe({name: 'number'})
 @Injectable()
 export class DecimalPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var digits: string = ListWrapper.first(args);
+  transform(value: any, digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Decimal, digits);
   }
 }
@@ -113,8 +111,7 @@ export class DecimalPipe extends NumberPipe implements PipeTransform {
 @Pipe({name: 'percent'})
 @Injectable()
 export class PercentPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var digits: string = ListWrapper.first(args);
+  transform(value: any, digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Percent, digits);
   }
 }
@@ -143,10 +140,8 @@ export class PercentPipe extends NumberPipe implements PipeTransform {
 @Pipe({name: 'currency'})
 @Injectable()
 export class CurrencyPipe extends NumberPipe implements PipeTransform {
-  transform(value: any, args: any[]): string {
-    var currencyCode: string = isPresent(args) && args.length > 0 ? args[0] : 'USD';
-    var symbolDisplay: boolean = isPresent(args) && args.length > 1 ? args[1] : false;
-    var digits: string = isPresent(args) && args.length > 2 ? args[2] : null;
+  transform(value: any, currencyCode: string = 'USD', symbolDisplay: boolean = false,
+            digits: string = null): string {
     return NumberPipe._format(value, NumberFormatStyle.Currency, digits, currencyCode,
                               symbolDisplay);
   }

modules/angular2/src/common/pipes/replace_pipe.ts

@@ -6,7 +6,6 @@ import {
   RegExpWrapper,
   StringWrapper
 } from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
 import {Injectable, PipeTransform, Pipe} from 'angular2/core';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
@@ -39,11 +38,7 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @Pipe({name: 'replace'})
 @Injectable()
 export class ReplacePipe implements PipeTransform {
-  transform(value: any, args: any[]): any {
-    if (isBlank(args) || args.length !== 2) {
-      throw new BaseException('ReplacePipe requires two arguments');
-    }
-
+  transform(value: any, pattern: string | RegExp, replacement: Function | string): any {
     if (isBlank(value)) {
       return value;
     }
@@ -53,9 +48,6 @@ export class ReplacePipe implements PipeTransform {
     }
 
     var input = value.toString();
-    var pattern = args[0];
-    var replacement = args[1];
-
 
     if (!this._supportedPattern(pattern)) {
       throw new InvalidPipeArgumentException(ReplacePipe, pattern);
@@ -67,16 +59,16 @@ export class ReplacePipe implements PipeTransform {
     // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
 
     if (isFunction(replacement)) {
-      var rgxPattern = isString(pattern) ? RegExpWrapper.create(pattern) : pattern;
+      var rgxPattern = isString(pattern) ? RegExpWrapper.create(<string>pattern) : <RegExp>pattern;
 
-      return StringWrapper.replaceAllMapped(input, rgxPattern, replacement);
+      return StringWrapper.replaceAllMapped(input, rgxPattern, <Function>replacement);
     }
     if (pattern instanceof RegExp) {
       // use the replaceAll variant
-      return StringWrapper.replaceAll(input, pattern, replacement);
+      return StringWrapper.replaceAll(input, pattern, <string>replacement);
     }
 
-    return StringWrapper.replace(input, pattern, replacement);
+    return StringWrapper.replace(input, <string>pattern, <string>replacement);
   }
 
   private _supportedInput(input: any): boolean { return isString(input) || isNumber(input); }

modules/angular2/src/common/pipes/slice_pipe.ts

@@ -1,5 +1,4 @@
 import {isBlank, isString, isArray, StringWrapper, CONST} from 'angular2/src/facade/lang';
-import {BaseException} from 'angular2/src/facade/exceptions';
 import {ListWrapper} from 'angular2/src/facade/collection';
 import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
@@ -59,16 +58,11 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @Pipe({name: 'slice', pure: false})
 @Injectable()
 export class SlicePipe implements PipeTransform {
-  transform(value: any, args: any[] = null): any {
-    if (isBlank(args) || args.length == 0) {
-      throw new BaseException('Slice pipe requires one argument');
-    }
+  transform(value: any, start: number, end: number = null): any {
     if (!this.supports(value)) {
       throw new InvalidPipeArgumentException(SlicePipe, value);
     }
     if (isBlank(value)) return value;
-    var start: number = args[0];
-    var end: number = args.length > 1 ? args[1] : null;
     if (isString(value)) {
       return StringWrapper.slice(value, start, end);
     }

modules/angular2/src/common/pipes/uppercase_pipe.ts

@@ -13,7 +13,7 @@ import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 @Pipe({name: 'uppercase'})
 @Injectable()
 export class UpperCasePipe implements PipeTransform {
-  transform(value: string, args: any[] = null): string {
+  transform(value: string): string {
     if (isBlank(value)) return value;
     if (!isString(value)) {
       throw new InvalidPipeArgumentException(UpperCasePipe, value);