Extension method support to move us closer to a valid List implementation.

test/generated_sdk/lib/core/annotations.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.core;
 
+// TODO(jacobr): move these annotations to a different package. E.g. dart:js
+
+class JsName {

[vsm, 2015/04/03 16:41:20]

Can you explain the use case for this annotation?

[Jacob, 2015/04/03 20:25:59]

example

// The d3 library is defined off a JavaScript object named d3
@JsName(name: "d3")
library d3_js;


// We choose to pretend that the type HTMLInputElement is named InputElement
@JsName('HTMLInputElement')
class InputElement {
...
}

+  /// The JavaScript name.
+  /// Used for classes and libraries.
+  /// Note that this could be an expression, e.g. `lib.TypeName` in JS, but it
+  /// should be kept simple, as it will be generated directly into the code.
+  final String name;
+  const JsName({this.name});
+}
+
+class JsPeerInterface {
+  /// The JavaScript type that we should match the API of.
+  /// Used for classes where Dart subclasses should be callable from JavaScript
+  /// matching the JavaScript calling conventions.
+  final String name;
+  const JsPeerInterface({this.name});
+}
+
+/// Whether an interface is allowed to have JavaScript implementations that
+/// use extension methods to provide custom Dart behavior.
+class SupportJsExtensionMethod {
+  const SupportJsExtensionMethod();
+}
+
 /**
  * The annotation `@Deprecated('expires when')` marks a feature as deprecated.
  *
  * The annotation `@deprecated` is a shorthand for deprecating until
  * an unspecified "next release".
  *
  * The intent of the `@Deprecated` annotation is to inform users of a feature
  * that they should change their code, even if it is currently still working
  * correctly.
  *
@@ skipping 116 matching lines @@
  *
  * Tools that understand `@proxy` should tell the user if a class using `@proxy`
  * does not override the `noSuchMethod` declared on [Object].
  *
  * The intent of the `@proxy` notation is to create objects that implement a
  * type (or multiple types) that are not known at compile time. If the types
  * are known at compile time, a class can be written that implements these
  * types.
  */
 const Object proxy = const _Proxy();