chore(ts): fix TODOs that were pending on 1.6 upgrade

Closes #4377

modules/angular2/manual_typings/traceur-runtime.d.ts

@@ -7,13 +7,6 @@
 // ES5, because they are redundant with lib.es6.d.ts.
 /// <reference path="../typings/es6-promise/es6-promise.d.ts"/>
 
-// es6-promise.d.ts chose a different name for this interface than TS lib.es6.d.ts
-// Generic Type Alises are in TS 1.6 (https://github.com/Microsoft/TypeScript/pull/3397)
-// So we cannot write:
-// declare type PromiseLike = Thenable;
-// Until then we use a workaround:
-interface PromiseLike<T> extends Thenable<T> {}
-
 // Extend the ES5 standard library with some ES6 features we polyfill at runtime
 // by loading es6-shim.js
 

modules/angular2/src/core/dom/browser_adapter.dart

@@ -478,6 +478,10 @@ class BrowserDomAdapter extends GenericBrowserDomAdapter {
   num performanceNow() {
     return window.performance.now();
   }
+
+  parse(s) {
+    throw 'not implemented';
+  }
 }
 
 var baseElement = null;

modules/angular2/src/core/dom/browser_adapter.ts

@@ -61,6 +61,7 @@ var _chromeNumKeyPadMap = {
 
 /* tslint:disable:requireParameterType */
 export class BrowserDomAdapter extends GenericBrowserDomAdapter {
+  parse(templateHtml: string) { throw new Error("parse not implemented"); }
   static makeCurrent() { setRootDomAdapter(new BrowserDomAdapter()); }
   hasProperty(element, name: string): boolean { return name in element; }
   setProperty(el: /*element*/ any, name: string, value: any) { el[name] = value; }

modules/angular2/src/core/dom/dom_adapter.ts

@@ -1,5 +1,4 @@
 import {isBlank} from 'angular2/src/core/facade/lang';
-import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 
 export var DOM: DomAdapter;
 
@@ -9,137 +8,129 @@ export function setRootDomAdapter(adapter: DomAdapter) {
   }
 }
 
-
-
-function _abstract() {
-  return new BaseException('This method is abstract');
-}
-
 /* tslint:disable:requireParameterType */
 /**
  * Provides DOM operations in an environment-agnostic way.
  */
-export class DomAdapter {
-  hasProperty(element, name: string): boolean { throw _abstract(); }
-  setProperty(el: Element, name: string, value: any) { throw _abstract(); }
-  getProperty(el: Element, name: string): any { throw _abstract(); }
-  invoke(el: Element, methodName: string, args: any[]): any { throw _abstract(); }
+export abstract class DomAdapter {
+  abstract hasProperty(element, name: string): boolean;
+  abstract setProperty(el: Element, name: string, value: any);
+  abstract getProperty(el: Element, name: string): any;
+  abstract invoke(el: Element, methodName: string, args: any[]): any;
 
-  logError(error) { throw _abstract(); }
-  log(error) { throw _abstract(); }
-  logGroup(error) { throw _abstract(); }
-  logGroupEnd() { throw _abstract(); }
+  abstract logError(error);
+  abstract log(error);
+  abstract logGroup(error);
+  abstract logGroupEnd();
 
   /**
    * Maps attribute names to their corresponding property names for cases
    * where attribute name doesn't match property name.
    */
-  get attrToPropMap(): StringMap<string, string> { throw _abstract(); }
+  attrToPropMap: StringMap<string, string>;
 
-  parse(templateHtml: string) { throw _abstract(); }
-  query(selector: string): any { throw _abstract(); }
-  querySelector(el, selector: string): HTMLElement { throw _abstract(); }
-  querySelectorAll(el, selector: string): any[] { throw _abstract(); }
-  on(el, evt, listener) { throw _abstract(); }
-  onAndCancel(el, evt, listener): Function { throw _abstract(); }
-  dispatchEvent(el, evt) { throw _abstract(); }
-  createMouseEvent(eventType): any { throw _abstract(); }
-  createEvent(eventType: string): any { throw _abstract(); }
-  preventDefault(evt) { throw _abstract(); }
-  isPrevented(evt): boolean { throw _abstract(); }
-  getInnerHTML(el): string { throw _abstract(); }
-  getOuterHTML(el): string { throw _abstract(); }
-  nodeName(node): string { throw _abstract(); }
-  nodeValue(node): string { throw _abstract(); }
-  type(node): string { throw _abstract(); }
-  content(node): any { throw _abstract(); }
-  firstChild(el): Node { throw _abstract(); }
-  nextSibling(el): Node { throw _abstract(); }
-  parentElement(el): Node { throw _abstract(); }
-  childNodes(el): Node[] { throw _abstract(); }
-  childNodesAsList(el): Node[] { throw _abstract(); }
-  clearNodes(el) { throw _abstract(); }
-  appendChild(el, node) { throw _abstract(); }
-  removeChild(el, node) { throw _abstract(); }
-  replaceChild(el, newNode, oldNode) { throw _abstract(); }
-  remove(el): Node { throw _abstract(); }
-  insertBefore(el, node) { throw _abstract(); }
-  insertAllBefore(el, nodes) { throw _abstract(); }
-  insertAfter(el, node) { throw _abstract(); }
-  setInnerHTML(el, value) { throw _abstract(); }
-  getText(el): string { throw _abstract(); }
-  setText(el, value: string) { throw _abstract(); }
-  getValue(el): string { throw _abstract(); }
-  setValue(el, value: string) { throw _abstract(); }
-  getChecked(el): boolean { throw _abstract(); }
-  setChecked(el, value: boolean) { throw _abstract(); }
-  createComment(text: string): any { throw _abstract(); }
-  createTemplate(html): HTMLElement { throw _abstract(); }
-  createElement(tagName, doc = null): HTMLElement { throw _abstract(); }
-  createTextNode(text: string, doc = null): Text { throw _abstract(); }
-  createScriptTag(attrName: string, attrValue: string, doc = null): HTMLElement {
-    throw _abstract();
-  }
-  createStyleElement(css: string, doc = null): HTMLStyleElement { throw _abstract(); }
-  createShadowRoot(el): any { throw _abstract(); }
-  getShadowRoot(el): any { throw _abstract(); }
-  getHost(el): any { throw _abstract(); }
-  getDistributedNodes(el): Node[] { throw _abstract(); }
-  clone /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/ { throw _abstract(); }
-  getElementsByClassName(element, name: string): HTMLElement[] { throw _abstract(); }
-  getElementsByTagName(element, name: string): HTMLElement[] { throw _abstract(); }
-  classList(element): any[] { throw _abstract(); }
-  addClass(element, classname: string) { throw _abstract(); }
-  removeClass(element, classname: string) { throw _abstract(); }
-  hasClass(element, classname: string): boolean { throw _abstract(); }
-  setStyle(element, stylename: string, stylevalue: string) { throw _abstract(); }
-  removeStyle(element, stylename: string) { throw _abstract(); }
-  getStyle(element, stylename: string): string { throw _abstract(); }
-  tagName(element): string { throw _abstract(); }
-  attributeMap(element): Map<string, string> { throw _abstract(); }
-  hasAttribute(element, attribute: string): boolean { throw _abstract(); }
-  getAttribute(element, attribute: string): string { throw _abstract(); }
-  setAttribute(element, name: string, value: string) { throw _abstract(); }
-  removeAttribute(element, attribute: string) { throw _abstract(); }
-  templateAwareRoot(el) { throw _abstract(); }
-  createHtmlDocument(): HTMLDocument { throw _abstract(); }
-  defaultDoc(): HTMLDocument { throw _abstract(); }
-  getBoundingClientRect(el) { throw _abstract(); }
-  getTitle(): string { throw _abstract(); }
-  setTitle(newTitle: string) { throw _abstract(); }
-  elementMatches(n, selector: string): boolean { throw _abstract(); }
-  isTemplateElement(el: any): boolean { throw _abstract(); }
-  isTextNode(node): boolean { throw _abstract(); }
-  isCommentNode(node): boolean { throw _abstract(); }
-  isElementNode(node): boolean { throw _abstract(); }
-  hasShadowRoot(node): boolean { throw _abstract(); }
-  isShadowRoot(node): boolean { throw _abstract(); }
-  importIntoDoc /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/ { throw _abstract(); }
-  adoptNode /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/ { throw _abstract(); }
-  isPageRule(rule): boolean { throw _abstract(); }
-  isStyleRule(rule): boolean { throw _abstract(); }
-  isMediaRule(rule): boolean { throw _abstract(); }
-  isKeyframesRule(rule): boolean { throw _abstract(); }
-  getHref(element): string { throw _abstract(); }
-  getEventKey(event): string { throw _abstract(); }
-  resolveAndSetHref(element, baseUrl: string, href: string) { throw _abstract(); }
-  cssToRules(css: string): any[] { throw _abstract(); }
-  supportsDOMEvents(): boolean { throw _abstract(); }
-  supportsNativeShadowDOM(): boolean { throw _abstract(); }
-  getGlobalEventTarget(target: string): any { throw _abstract(); }
-  getHistory(): History { throw _abstract(); }
-  getLocation(): Location { throw _abstract(); }
-  getBaseHref(): string { throw _abstract(); }
-  resetBaseElement(): void { throw _abstract(); }
-  getUserAgent(): string { throw _abstract(); }
-  setData(element, name: string, value: string) { throw _abstract(); }
-  getComputedStyle(element): any { throw _abstract(); }
-  getData(element, name: string): string { throw _abstract(); }
-  setGlobalVar(name: string, value: any) { throw _abstract(); }
-  requestAnimationFrame(callback): number { throw _abstract(); }
-  cancelAnimationFrame(id) { throw _abstract(); }
-  performanceNow(): number { throw _abstract(); }
-  getAnimationPrefix(): string { throw _abstract(); }
-  getTransitionEnd(): string { throw _abstract(); }
-  supportsAnimation(): boolean { throw _abstract(); }
+  abstract parse(templateHtml: string);
+  abstract query(selector: string): any;
+  abstract querySelector(el, selector: string): HTMLElement;
+  abstract querySelectorAll(el, selector: string): any[];
+  abstract on(el, evt, listener);
+  abstract onAndCancel(el, evt, listener): Function;
+  abstract dispatchEvent(el, evt);
+  abstract createMouseEvent(eventType): any;
+  abstract createEvent(eventType: string): any;
+  abstract preventDefault(evt);
+  abstract isPrevented(evt): boolean;
+  abstract getInnerHTML(el): string;
+  abstract getOuterHTML(el): string;
+  abstract nodeName(node): string;
+  abstract nodeValue(node): string;
+  abstract type(node): string;
+  abstract content(node): any;
+  abstract firstChild(el): Node;
+  abstract nextSibling(el): Node;
+  abstract parentElement(el): Node;
+  abstract childNodes(el): Node[];
+  abstract childNodesAsList(el): Node[];
+  abstract clearNodes(el);
+  abstract appendChild(el, node);
+  abstract removeChild(el, node);
+  abstract replaceChild(el, newNode, oldNode);
+  abstract remove(el): Node;
+  abstract insertBefore(el, node);
+  abstract insertAllBefore(el, nodes);
+  abstract insertAfter(el, node);
+  abstract setInnerHTML(el, value);
+  abstract getText(el): string;
+  abstract setText(el, value: string);
+  abstract getValue(el): string;
+  abstract setValue(el, value: string);
+  abstract getChecked(el): boolean;
+  abstract setChecked(el, value: boolean);
+  abstract createComment(text: string): any;
+  abstract createTemplate(html): HTMLElement;
+  abstract createElement(tagName, doc?): HTMLElement;
+  abstract createTextNode(text: string, doc?): Text;
+  abstract createScriptTag(attrName: string, attrValue: string, doc?): HTMLElement;
+  abstract createStyleElement(css: string, doc?): HTMLStyleElement;
+  abstract createShadowRoot(el): any;
+  abstract getShadowRoot(el): any;
+  abstract getHost(el): any;
+  abstract getDistributedNodes(el): Node[];
+  abstract clone /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract getElementsByClassName(element, name: string): HTMLElement[];
+  abstract getElementsByTagName(element, name: string): HTMLElement[];
+  abstract classList(element): any[];
+  abstract addClass(element, classname: string);
+  abstract removeClass(element, classname: string);
+  abstract hasClass(element, classname: string): boolean;
+  abstract setStyle(element, stylename: string, stylevalue: string);
+  abstract removeStyle(element, stylename: string);
+  abstract getStyle(element, stylename: string): string;
+  abstract tagName(element): string;
+  abstract attributeMap(element): Map<string, string>;
+  abstract hasAttribute(element, attribute: string): boolean;
+  abstract getAttribute(element, attribute: string): string;
+  abstract setAttribute(element, name: string, value: string);
+  abstract removeAttribute(element, attribute: string);
+  abstract templateAwareRoot(el);
+  abstract createHtmlDocument(): HTMLDocument;
+  abstract defaultDoc(): HTMLDocument;
+  abstract getBoundingClientRect(el);
+  abstract getTitle(): string;
+  abstract setTitle(newTitle: string);
+  abstract elementMatches(n, selector: string): boolean;
+  abstract isTemplateElement(el: any): boolean;
+  abstract isTextNode(node): boolean;
+  abstract isCommentNode(node): boolean;
+  abstract isElementNode(node): boolean;
+  abstract hasShadowRoot(node): boolean;
+  abstract isShadowRoot(node): boolean;
+  abstract importIntoDoc /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract adoptNode /*<T extends Node>*/ (node: Node /*T*/): Node /*T*/;
+  abstract isPageRule(rule): boolean;
+  abstract isStyleRule(rule): boolean;
+  abstract isMediaRule(rule): boolean;
+  abstract isKeyframesRule(rule): boolean;
+  abstract getHref(element): string;
+  abstract getEventKey(event): string;
+  abstract resolveAndSetHref(element, baseUrl: string, href: string);
+  abstract cssToRules(css: string): any[];
+  abstract supportsDOMEvents(): boolean;
+  abstract supportsNativeShadowDOM(): boolean;
+  abstract getGlobalEventTarget(target: string): any;
+  abstract getHistory(): History;
+  abstract getLocation(): Location;
+  abstract getBaseHref(): string;
+  abstract resetBaseElement(): void;
+  abstract getUserAgent(): string;
+  abstract setData(element, name: string, value: string);
+  abstract getComputedStyle(element): any;
+  abstract getData(element, name: string): string;
+  abstract setGlobalVar(name: string, value: any);
+  abstract requestAnimationFrame(callback): number;
+  abstract cancelAnimationFrame(id);
+  abstract performanceNow(): number;
+  abstract getAnimationPrefix(): string;
+  abstract getTransitionEnd(): string;
+  abstract supportsAnimation(): boolean;
 }

modules/angular2/src/core/dom/generic_browser_adapter.ts

@@ -5,7 +5,7 @@ import {DomAdapter} from './dom_adapter';
 /**
  * Provides DOM operations in any browser environment.
  */
-export class GenericBrowserDomAdapter extends DomAdapter {
+export abstract class GenericBrowserDomAdapter extends DomAdapter {
   private _animationPrefix: string = null;
   private _transitionEnd: string = null;
   constructor() {

modules/angular2/src/core/dom/html_adapter.dart

@@ -46,6 +46,10 @@ class Html5LibDomAdapter implements DomAdapter {
     'tabindex': 'tabIndex',
   };
 
+  set attrToPropMap(value) {
+    throw 'readonly';
+  }
+
   @override
   getGlobalEventTarget(String target) {
     throw 'not implemented';

modules/angular2/src/core/dom/parse5_adapter.ts

@@ -562,6 +562,11 @@ export class Parse5DomAdapter extends DomAdapter {
   getAnimationPrefix(): string { return ''; }
   getTransitionEnd(): string { return 'transitionend'; }
   supportsAnimation(): boolean { return true; }
+
+  replaceChild(el, newNode, oldNode) { throw new Error('not implemented'); }
+  parse(templateHtml: string) { throw new Error('not implemented'); }
+  invoke(el: Element, methodName: string, args: any[]): any { throw new Error('not implemented'); }
+  getEventKey(event): string { throw new Error('not implemented'); }
 }
 
 // TODO: build a proper list, this one is all the keys of a HTMLInputElement

modules/angular2/src/core/facade/lang.dart

@@ -17,10 +17,6 @@ class CONST {
   const CONST();
 }
 
-class ABSTRACT {
-  const ABSTRACT();
-}
-
 bool isPresent(obj) => obj != null;
 bool isBlank(obj) => obj == null;
 bool isString(obj) => obj is String;

modules/angular2/src/core/facade/lang.ts

@@ -62,10 +62,6 @@ export function CONST(): ClassDecorator {
   return (target) => target;
 }
 
-export function ABSTRACT(): ClassDecorator {
-  return (t) => t;
-}
-
 export function isPresent(obj: any): boolean {
   return obj !== undefined && obj !== null;
 }

modules/angular2/src/core/forms/directives/ng_control.ts

@@ -2,10 +2,13 @@ import {ControlValueAccessor} from './control_value_accessor';
 import {AbstractControlDirective} from './abstract_control_directive';
 
 /**
- * An abstract class that all control directive extend.
- *
+ * A base class that all control directive extend.
  * It binds a {@link Control} object to a DOM element.
  */
+// Cannot currently be abstract because it would contain
+// an abstract method in the public API, and we cannot reflect
+// on that in Dart due to https://github.com/dart-lang/sdk/issues/18721
+// Also we don't have abstract setters, see https://github.com/Microsoft/TypeScript/issues/4669
 export class NgControl extends AbstractControlDirective {
   name: string = null;
   valueAccessor: ControlValueAccessor = null;

modules/angular2/src/core/metadata/view.ts

@@ -1,4 +1,4 @@
-import {ABSTRACT, CONST, Type} from 'angular2/src/core/facade/lang';
+import {CONST, Type} from 'angular2/src/core/facade/lang';
 import {ViewEncapsulation} from 'angular2/src/core/render/api';
 
 export {ViewEncapsulation} from 'angular2/src/core/render/api';

modules/angular2/src/core/pipes/invalid_pipe_argument_exception.ts

@@ -1,4 +1,4 @@
-import {ABSTRACT, CONST, Type} from 'angular2/src/core/facade/lang';
+import {CONST, Type} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 
 export class InvalidPipeArgumentException extends BaseException {

modules/angular2/src/http/interfaces.ts

@@ -11,15 +11,15 @@ import {URLSearchParams} from './url_search_params';
  * The primary purpose of a `ConnectionBackend` is to create new connections to fulfill a given
  * {@link Request}.
  */
-export class ConnectionBackend {
+export abstract class ConnectionBackend {
   constructor() {}
-  createConnection(request: any): Connection { throw new BaseException('Abstract!'); }
+  abstract createConnection(request: any): Connection;
 }
 
 /**
  * Abstract class from which real connections are derived.
  */
-export class Connection {
+export abstract class Connection {
   readyState: ReadyStates;
   request: Request;
   response: EventEmitter;  // TODO: generic of <Response>;

modules/angular2/src/mock/mock_location_strategy.ts

@@ -38,4 +38,6 @@ export class MockLocationStrategy extends LocationStrategy {
       this.simulatePopState(nextUrl);
     }
   }
+
+  forward(): void { throw 'not implemented'; }
 }

modules/angular2/src/router/location_strategy.ts

@@ -1,9 +1,3 @@
-import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
-
-function _abstract() {
-  return new BaseException('This method is abstract');
-}
-
 /**
  * `LocationStrategy` is responsible for representing and reading route state
  * from the the browser's URL. Angular provides two strategies:
@@ -20,11 +14,11 @@ function _abstract() {
  *
  * See these two classes for more.
  */
-export class LocationStrategy {
-  path(): string { throw _abstract(); }
-  pushState(ctx: any, title: string, url: string): void { throw _abstract(); }
-  forward(): void { throw _abstract(); }
-  back(): void { throw _abstract(); }
-  onPopState(fn: (_: any) => any): void { throw _abstract(); }
-  getBaseHref(): string { throw _abstract(); }
+export abstract class LocationStrategy {
+  abstract path(): string;
+  abstract pushState(ctx: any, title: string, url: string): void;
+  abstract forward(): void;
+  abstract back(): void;
+  abstract onPopState(fn: (_: any) => any): void;
+  abstract getBaseHref(): string;
 }

modules/angular2/src/web_workers/shared/message_bus.ts

@@ -1,19 +1,14 @@
 import {EventEmitter} from 'angular2/src/core/facade/async';
-import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 import {NgZone} from 'angular2/src/core/zone/ng_zone';
 export {EventEmitter, Observable} from 'angular2/src/core/facade/async';
 
-function _abstract() {
-  throw new BaseException("This method is abstract");
-}
-
 /**
  * Message Bus is a low level API used to communicate between the UI and the background.
  * Communication is based on a channel abstraction. Messages published in a
  * given channel to one MessageBusSink are received on the same channel
  * by the corresponding MessageBusSource.
  */
-export /* abstract (with TS 1.6) */ class MessageBus implements MessageBusSource, MessageBusSink {
+export abstract class MessageBus implements MessageBusSource, MessageBusSink {
   /**
    * Sets up a new channel on the MessageBus.
    * MUST be called before calling from or to on the channel.
@@ -22,27 +17,27 @@ export /* abstract (with TS 1.6) */ class MessageBus implements MessageBusSource
    * if runInZone is false then the source will emit events inside the global zone
    * and the sink will send messages immediately.
    */
-  initChannel(channel: string, runInZone: boolean = true): void { throw _abstract(); }
+  abstract initChannel(channel: string, runInZone?: boolean): void;
 
   /**
    * Assigns this bus to the given zone.
    * Any callbacks attached to channels where runInZone was set to true on initialization
    * will be executed in the given zone.
    */
-  attachToZone(zone: NgZone): void { throw _abstract(); }
+  abstract attachToZone(zone: NgZone): void;
 
   /**
    * Returns an {@link EventEmitter} that emits every time a message
    * is received on the given channel.
    */
-  from(channel: string): EventEmitter { throw _abstract(); }
+  abstract from(channel: string): EventEmitter;
 
 
   /**
    * Returns an {@link EventEmitter} for the given channel
    * To publish methods to that channel just call next (or add in dart) on the returned emitter
    */
-  to(channel: string): EventEmitter { throw _abstract(); }
+  abstract to(channel: string): EventEmitter;
 }
 
 export interface MessageBusSource {

modules/angular2/test/symbol_inspector/symbol_differ.ts

@@ -1,7 +1,7 @@
 import {StringWrapper, RegExpWrapper, isJsObject} from 'angular2/src/core/facade/lang';
 
 var IS_FIELD = RegExpWrapper.create('^\\w+[\\.|\\#]\\w+=?$');
-var IS_INTERFACE = RegExpWrapper.create('^\\{\\w+\\}');
+var IS_INTERFACE = RegExpWrapper.create('^\\{.+\\}');
 var IS_DART = RegExpWrapper.create('\\:dart$');
 var IS_JS = RegExpWrapper.create('\\:js$');
 var IS_OPTIONAL = RegExpWrapper.create('\\:optional$');

modules/benchpress/src/metric.ts

@@ -1,14 +1,12 @@
 import {bind, Binding} from 'angular2/src/core/di';
 import {Promise, PromiseWrapper} from 'angular2/src/core/facade/async';
-import {ABSTRACT} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 import {StringMap} from 'angular2/src/core/facade/collection';
 
 /**
  * A metric is measures values
  */
-@ABSTRACT()
-export class Metric {
+export abstract class Metric {
   static bindTo(delegateToken): Binding[] {
     return [bind(Metric).toFactory((delegate) => delegate, [delegateToken])];
   }

modules/benchpress/src/reporter.ts

@@ -1,14 +1,12 @@
 import {bind, Binding} from 'angular2/src/core/di';
 import {Promise, PromiseWrapper} from 'angular2/src/core/facade/async';
-import {ABSTRACT} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 import {MeasureValues} from './measure_values';
 
 /**
  * A reporter reports measure values and the valid sample.
  */
-@ABSTRACT()
-export class Reporter {
+export abstract class Reporter {
   static bindTo(delegateToken): Binding[] {
     return [bind(Reporter).toFactory((delegate) => delegate, [delegateToken])];
   }

modules/benchpress/src/validator.ts

@@ -1,6 +1,5 @@
 import {bind, Binding} from 'angular2/src/core/di';
 import {StringMap} from 'angular2/src/core/facade/collection';
-import {ABSTRACT} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 
 import {MeasureValues} from './measure_values';
@@ -10,8 +9,7 @@ import {MeasureValues} from './measure_values';
  * A valid sample is a sample that represents the population that should be observed
  * in the correct way.
  */
-@ABSTRACT()
-export class Validator {
+export abstract class Validator {
   static bindTo(delegateToken): Binding[] {
     return [bind(Validator).toFactory((delegate) => delegate, [delegateToken])];
   }

modules/benchpress/src/web_driver_adapter.ts

@@ -1,6 +1,5 @@
 import {bind, Binding} from 'angular2/src/core/di';
 import {Promise} from 'angular2/src/core/facade/async';
-import {ABSTRACT} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 import {Map} from 'angular2/src/core/facade/collection';
 
@@ -9,8 +8,7 @@ import {Map} from 'angular2/src/core/facade/collection';
  * e.g. JS vs Dart Async vs Dart Sync webdriver.
  * Needs one implementation for every supported WebDriver client.
  */
-@ABSTRACT()
-export class WebDriverAdapter {
+export abstract class WebDriverAdapter {
   static bindTo(delegateToken): Binding[] {
     return [bind(WebDriverAdapter).toFactory((delegate) => delegate, [delegateToken])];
   }

modules/benchpress/src/web_driver_extension.ts

@@ -1,6 +1,6 @@
 import {bind, Binding, Injector, OpaqueToken} from 'angular2/src/core/di';
 
-import {ABSTRACT, isBlank, isPresent} from 'angular2/src/core/facade/lang';
+import {isBlank, isPresent} from 'angular2/src/core/facade/lang';
 import {BaseException, WrappedException} from 'angular2/src/core/facade/exceptions';
 import {Promise, PromiseWrapper} from 'angular2/src/core/facade/async';
 import {ListWrapper, StringMap} from 'angular2/src/core/facade/collection';
@@ -12,8 +12,7 @@ import {Options} from './common_options';
  * for a given browser, independent of the WebDriverAdapter.
  * Needs one implementation for every supported Browser.
  */
-@ABSTRACT()
-export class WebDriverExtension {
+export abstract class WebDriverExtension {
   static bindTo(childTokens): Binding[] {
     var res = [
       bind(_CHILDREN)

npm-shrinkwrap.clean.json

@@ -10026,7 +10026,7 @@
       }
     },
     "ts2dart": {
-      "version": "0.7.7",
+      "version": "0.7.9",
       "dependencies": {
         "source-map": {
           "version": "0.4.4",

npm-shrinkwrap.json

@@ -15496,9 +15496,9 @@
       }
     },
     "ts2dart": {
-      "version": "0.7.7",
-      "from": "https://registry.npmjs.org/ts2dart/-/ts2dart-0.7.7.tgz",
-      "resolved": "https://registry.npmjs.org/ts2dart/-/ts2dart-0.7.7.tgz",
+      "version": "0.7.9",
+      "from": "ts2dart@0.7.9",
+      "resolved": "https://registry.npmjs.org/ts2dart/-/ts2dart-0.7.9.tgz",
       "dependencies": {
         "source-map": {
           "version": "0.4.4",

package.json

@@ -128,7 +128,7 @@
     "temp": "^0.8.1",
     "ternary-stream": "^1.2.3",
     "through2": "^0.6.1",
-    "ts2dart": "^0.7.7",
+    "ts2dart": "^0.7.9",
     "tsd": "^0.6.5-beta",
     "tslint": "^2.5.0",
     "typescript": "^1.6.2",