Add @JSName annotation for native fields and methods.

sdk/lib/_internal/compiler/implementation/native_handler.dart

 // Copyright (c) 2012, 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.
 
 library native;
 
 import 'dart:uri';
 import 'dart2jslib.dart' hide SourceString;
 import 'elements/elements.dart';
 import 'js_backend/js_backend.dart';
@@ skipping 17 matching lines @@
 }
 
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
   /// Initial entry point to native enqueuer.
   void processNativeClasses(Collection<LibraryElement> libraries) {}
 
+  /// Notification of a main Enqueuer worklist element.  For methods, adds
+  /// information from metadata attributes, and computes types instantiated due
+  /// to calling the method.
   void registerElement(Element element) {}
 
-  /// Method is a member of a native class.
-  void registerMethod(Element method) {}
+  /// Notification of native field.  Adds information from metadata attributes.
+  void registerField(Element field) {}
 
-  /// Compute types instantiated due to getting a native field.
+  /// Computes types instantiated due to getting a native field.
   void registerFieldLoad(Element field) {}
 
-  /// Compute types instantiated due to setting a native field.
+  /// Computes types instantiated due to setting a native field.
   void registerFieldStore(Element field) {}
 
   /**
    * Handles JS-calls, which can be an instantiation point for types.
    *
    * For example, the following code instantiates and returns native classes
    * that are `_DOMWindowImpl` or a subtype.
    *
    *     JS('_DOMWindowImpl', 'window')
    *
@@ skipping 29 matching lines @@
   final queue = new Queue();
   bool flushing = false;
 
 
   final Enqueuer world;
   final Compiler compiler;
   final bool enableLiveTypeAnalysis;
 
   ClassElement _annotationCreatesClass;
   ClassElement _annotationReturnsClass;
+  ClassElement _annotationJsNameClass;
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(this.world, this.compiler, this.enableLiveTypeAnalysis);
 
   void processNativeClasses(Collection<LibraryElement> libraries) {
     libraries.forEach(processNativeClassesInLibrary);
     if (!enableLiveTypeAnalysis) {
       nativeClasses.forEach((c) => enqueueClass(c, 'forced'));
       flushQueue();
     }
   }
 
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
       if (element.kind == ElementKind.CLASS) {
         ClassElement classElement = element;
         if (classElement.isNative()) {
           nativeClasses.add(classElement);
           unusedClasses.add(classElement);
 
           // Resolve class to ensure the class has valid inheritance info.
           classElement.ensureResolved(compiler);
         }
       }
     });
   }
 
   ClassElement get annotationCreatesClass {
-    if (_annotationCreatesClass == null) findAnnotationClasses();
+    findAnnotationClasses();
     return _annotationCreatesClass;
   }
 
   ClassElement get annotationReturnsClass {
-    if (_annotationReturnsClass == null) findAnnotationClasses();
+    findAnnotationClasses();
     return _annotationReturnsClass;
   }
 
+  ClassElement get annotationJsNameClass {
+    findAnnotationClasses();
+    return _annotationJsNameClass;
+  }
+
   void findAnnotationClasses() {
+    if (_annotationCreatesClass != null) return;
     ClassElement find(name) {
       Element e = compiler.findHelper(name);
       if (e == null || e is! ClassElement) {
         compiler.cancel("Could not find implementation class '${name}'");
       }
       return e;
     }
     _annotationCreatesClass = find(const SourceString('Creates'));
     _annotationReturnsClass = find(const SourceString('Returns'));
+    _annotationJsNameClass = find(const SourceString('JSName'));
   }
 
+  /// Returns the JSName annotation string or `null` if no JSName annotation is
+  /// present.
+  String findJsNameFromAnnotation(Element element) {

[ahe, 2012/11/29 09:19:26]

This file should be deleted when we get rid of the native keyword.  The purpose
of this file is to isolate support for the legacy support for the frog native
keyword feature.

I assume this method should survive the legacy support for native keyword, so it
probably doesn't belong in this file.

+    String name = null;
+    ClassElement annotationClass = annotationJsNameClass;
+    for (Link<MetadataAnnotation> link = element.metadata;
+         !link.isEmpty;
+         link = link.tail) {
+      MetadataAnnotation annotation = link.head.ensureResolved(compiler);

[ahe, 2012/11/29 09:19:26]

I'm think we should make this an operation on element.  For example:

Link<MetadataAnnotation> metadata = element.getResolvedMetadata(compiler);

+      var value = annotation.value;
+      if (value is! ConstructedConstant) continue;
+      if (value.type is! InterfaceType) continue;
+      if (!identical(value.type.element, annotationClass)) continue;
+
+      var fields = value.fields;
+      // TODO(sra): Better validation of the constant.

[ahe, 2012/11/29 09:19:26]

The constant will be validated in checked mode.  We could change the constant
evaluator to warn about things that it knows will fail in checked mode.

+      if (fields.length != 1 || fields[0] is! StringConstant) {
+        PartialMetadataAnnotation partial = annotation;
+        compiler.cancel(
+            'Annotations needs one string: ${partial.parseNode(compiler)}');

[ahe, 2012/11/29 09:19:26]

This should be:

compiler.internalError('Annotations needs one string', node:
partial.parseNode(compiler));

But I'll make MetadataAnnotation implement Spannable so it is easier to use for
a location.

[sra1, 2012/12/04 01:31:31]

This would be sufficient for Issue 7007.

+      }
+      String specString = fields[0].toDartString().slowToString();
+      if (name == null) {
+        name = specString;
+      } else {
+        PartialMetadataAnnotation partial = annotation;
+        compiler.cancel(
+            'Too many JSName annotations: ${partial.parseNode(compiler)}');

[ahe, 2012/11/29 09:19:26]

Ditto.

+      }
+    }
+    return name;
+  }
 
   enqueueClass(ClassElement classElement, cause) {
     assert(unusedClasses.contains(classElement));
     unusedClasses.remove(classElement);
     pendingClasses.add(classElement);
     queue.add(() { processClass(classElement, cause); });
   }
 
   void flushQueue() {
     if (flushing) return;
@@ skipping 19 matching lines @@
 
     if (firstTime) {
       queue.add(onFirstNativeClass);
     }
   }
 
   registerElement(Element element) {
     if (element.isFunction()) return registerMethod(element);
   }
 
+  registerField(Element element) {
+    if (element.enclosingElement.isNative()) {
+      setNativeName(element);
+    }
+  }
+
   registerMethod(Element method) {
     if (isNativeMethod(method)) {
+      setNativeName(method);
       processNativeBehavior(
           NativeBehavior.ofMethod(method, compiler),
           method);
       flushQueue();
     }
   }
 
+  /// Sets the native name of [element], either from an annotation, or
+  /// defaulting to the Dart name.
+  void setNativeName(Element element) {
+    String name = findJsNameFromAnnotation(element);
+    if (name == null) name = element.name.slowToString();
+    element.setNative(name);
+  }
+
   bool isNativeMethod(Element element) {
     if (!element.getLibrary().canUseNative) return false;
     // Native method?
     return compiler.withCurrentElement(element, () {
       Node node = element.parseNode(compiler);
       if (node is! FunctionExpression) return false;
       node = node.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
@@ skipping 455 matching lines @@
     listener.endLiteralString(0);
     token = token.next;
   }
   listener.endReturnStatement(hasExpression, begin, token);
   // TODO(ngeoffray): expect a ';'.
   // Currently there are method with both native marker and Dart body.
   return token.next;
 }
 
 SourceString checkForNativeClass(ElementListener listener) {
-  SourceString nativeName;
+  SourceString nativeTagInfo;
   Node node = listener.nodes.head;
   if (node != null
       && node.asIdentifier() != null
       && node.asIdentifier().source.stringValue == 'native') {
-    nativeName = node.asIdentifier().token.next.value;
+    nativeTagInfo = node.asIdentifier().token.next.value;
     listener.popNode();
   }
-  return nativeName;
+  return nativeTagInfo;
 }
 
 bool isOverriddenMethod(FunctionElement element,
                         ClassElement cls,
                         NativeEmitter nativeEmitter) {
   List<ClassElement> subtypes = nativeEmitter.subtypes[cls];
   if (subtypes == null) return false;
   for (ClassElement subtype in subtypes) {
     if (subtype.lookupLocalMember(element.name) != null) return true;
   }
   return false;
 }
 
 final RegExp nativeRedirectionRegExp = new RegExp(r'^[a-zA-Z][a-zA-Z_$0-9]*$');
 
 void handleSsaNative(SsaBuilder builder, Expression nativeBody) {
   Compiler compiler = builder.compiler;
   FunctionElement element = builder.work.element;
-  element.setNative();
   NativeEmitter nativeEmitter = builder.emitter.nativeEmitter;
   // If what we're compiling is a getter named 'typeName' and the native
   // class is named 'DOMType', we generate a call to the typeNameOf
   // function attached on the isolate.
   // The DOM classes assume that their 'typeName' property, which is
   // not a JS property on the DOM types, returns the type name.
   if (element.name == const SourceString('typeName')
       && element.isGetter()
       && nativeEmitter.toNativeName(element.getEnclosingClass()) == 'DOMType') {
     Element helper =
         compiler.findHelper(const SourceString('getTypeNameOf'));
     builder.pushInvokeHelper1(helper, builder.localsHandler.readThis());
     builder.close(new HReturn(builder.pop())).addSuccessor(builder.graph.exit);
   }
 
   HInstruction convertDartClosure(Element parameter, FunctionType type) {
     HInstruction local = builder.localsHandler.readLocal(parameter);
     Constant arityConstant =
         builder.constantSystem.createInt(type.computeArity());
     HInstruction arity = builder.graph.addConstant(arityConstant);
     // TODO(ngeoffray): For static methods, we could pass a method with a
     // defined arity.
     Element helper = builder.interceptors.getClosureConverter();
     builder.pushInvokeHelper2(helper, local, arity);
     HInstruction closure = builder.pop();
     return closure;
   }
 
   // Check which pattern this native method follows:
-  // 1) foo() native; hasBody = false, isRedirecting = false
-  // 2) foo() native "bar"; hasBody = false, isRedirecting = true
-  // 3) foo() native "return 42"; hasBody = true, isRedirecting = false
+  // 1) foo() native;
+  //      hasBody = false, isRedirecting = false
+  // 2) foo() native "bar";
+  //      hasBody = false, isRedirecting = true, no longer supported.
+  // 3) foo() native "return 42";
+  //      hasBody = true, isRedirecting = false
   bool hasBody = false;
-  bool isRedirecting = false;
-  String nativeMethodName = element.name.slowToString();
+  String nativeMethodName = element.nativeName();
   if (nativeBody != null) {
     LiteralString jsCode = nativeBody.asLiteralString();
     String str = jsCode.dartString.slowToString();
     if (nativeRedirectionRegExp.hasMatch(str)) {
-      nativeMethodName = str;
-      isRedirecting = true;
-      nativeEmitter.addRedirectingMethod(element, nativeMethodName);
-    } else {
-      hasBody = true;
+      compiler.cancel("Deprecated syntax, use @JSName('name') instead.",
+                      node: nativeBody);
     }
+    hasBody = true;
   }
 
   if (!hasBody) {
     nativeEmitter.nativeMethods.add(element);
   }
 
   FunctionSignature parameters = element.computeSignature(builder.compiler);
   if (!hasBody) {
     List<String> arguments = <String>[];
     List<HInstruction> inputs = <HInstruction>[];
@@ skipping 93 matching lines @@
                                       String parameters) {
   buffer.add("  if (Object.getPrototypeOf(this).hasOwnProperty");
   buffer.add("('$methodName')) {\n");
   buffer.add("  $code");
   buffer.add("  } else {\n");
   buffer.add("    return Object.prototype.$methodName.call(this");
   buffer.add(parameters == '' ? '' : ', $parameters');
   buffer.add(");\n");
   buffer.add("  }\n");
 }