Sets the native name of static native methods by using the @JSName with the @Native tag of the encl…

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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 native;
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
@@ skipping 381 matching lines @@
       // function or a non-method property in the prototype chain, must be coded
       // using a JS-call.
       if (element.isInstanceMember) {
         setNativeName(element);
       }
     }
   }
 
   handleMethodAnnotations(Element method) {
     if (isNativeMethod(method)) {
-      setNativeName(method);
+      if (method.isStatic) {
+        setStaticNativeMethodName(method);

[sra1, 2015/03/03 02:00:02]

better name:  setNativeNameForStaticMethod

[Harry Terkelsen, 2015/03/03 03:02:16]

Done.

+      } else {
+        setNativeName(method);
+      }
     }
   }
 
   /// 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;
     element.setNative(name);
   }
 
+  /// Sets the native name of the static native method [element], using the
+  /// following rules:
+  /// 1. If [element] has a @JSName annotation that is an identifier, qualify
+  ///    that identifier to the @Native name of the enclosing class
+  /// 2. If [element] has a @JSName annotation that is not an identifier,
+  ///    use the declared @JSName as the expression
+  /// 3. If [element] does not have a @JSName annotation, qualify the name of
+  ///    the method with the @Native name of the enclosing class.
+  void setStaticNativeMethodName(Element element) {
+    String name = findJsNameFromAnnotation(element);
+    if (name == null) name = element.name;
+    if (isIdentifier(name)) {
+      String nativeName = unquote(element.enclosingClass.nativeTagInfo);

[sra1, 2015/03/03 02:00:02]

There is code somewhere that parses the tag info.
Find that and use it.
The parsing should occur in only one place.
If the native tag info is messed up we need the compiler to signal an error
rather than generate bad code.

@Native("ApplicationCache,DOMApplicationCache,OfflineResourceList")
class ApplicationCache extends EventTarget {

[Harry Terkelsen, 2015/03/03 03:02:16]

Done.

+      element.setNative('$nativeName.$name');
+    } else {
+      element.setNative(name);
+    }
+  }
+
+  bool isIdentifier(String s) =>
+      new RegExp(r'^[a-zA-Z_$][a-zA-Z0-9_$]*$').hasMatch(s);

[sra1, 2015/03/03 02:00:02]

Put regexp in a static class variable so it is not parsed and compiled each
time.

[Harry Terkelsen, 2015/03/03 03:02:16]

Done.

+
+  String unquote(String s) {
+    if (s.length < 2) return s;
+    if (s[0] == '"' && s[s.length - 1] == '"') {
+      return s.substring(1, s.length - 1);
+    }
+    return s;
+  }
+
   bool isNativeMethod(FunctionElementX element) {
     if (!element.library.canUseNative) return false;
     // Native method?
     return compiler.withCurrentElement(element, () {
       Node node = element.parseNode(compiler);
       if (node is! FunctionExpression) return false;
       FunctionExpression functionExpression = node;
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
@@ skipping 208 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }