Add @JSName annotation for native fields and methods - second try.

sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.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.
 
 part of js_backend;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 13 matching lines @@
 
   // Caches the native methods that are overridden by a native class.
   // Note that the method that overrides does not have to be native:
   // it's the overridden method that must make sure it will dispatch
   // to its subclass if it sees an instance whose class is a subclass.
   Set<FunctionElement> overriddenMethods;
 
   // Caches the methods that have a native body.
   Set<FunctionElement> nativeMethods;
 
-  // Caches the methods that redirect to a JS method.
-  Map<FunctionElement, String> redirectingMethods;
-
   // Do we need the native emitter to take care of handling
   // noSuchMethod for us? This flag is set to true in the emitter if
   // it finds any native class that needs noSuchMethod handling.
   bool handleNoSuchMethod = false;
 
   NativeEmitter(this.emitter)
       : classesWithDynamicDispatch = new Set<ClassElement>(),
         nativeClasses = new Set<ClassElement>(),
         subtypes = new Map<ClassElement, List<ClassElement>>(),
         directSubtypes = new Map<ClassElement, List<ClassElement>>(),
         overriddenMethods = new Set<FunctionElement>(),
         nativeMethods = new Set<FunctionElement>(),
-        redirectingMethods = new Map<FunctionElement, String>(),
         nativeBuffer = new CodeBuffer();
 
   Compiler get compiler => emitter.compiler;
   JavaScriptBackend get backend => compiler.backend;
 
-  void addRedirectingMethod(FunctionElement element, String name) {
-    redirectingMethods[element] = name;
-  }
-
   String get dynamicName {
     Element element = compiler.findHelper(
         const SourceString('dynamicFunction'));
     return backend.namer.isolateAccess(element);
   }
 
   String get dynamicSetMetadataName {
     Element element = compiler.findHelper(
         const SourceString('dynamicSetMetadata'));
     return backend.namer.isolateAccess(element);
@@ skipping 39 matching lines @@
     if (method !== '') {
       if (hasOwnProperty.call(desc, method)) {
         $dynamicName(method)[cls] = desc[method];
       }
     }
   }
 }""";
   }
 
   void generateNativeLiteral(ClassElement classElement) {
-    String quotedNative = classElement.nativeName.slowToString();
+    String quotedNative = classElement.nativeTagInfo.slowToString();
     String nativeCode = quotedNative.substring(2, quotedNative.length - 1);
     String className = backend.namer.getName(classElement);
     nativeBuffer.add(className);
     nativeBuffer.add(' = ');
     nativeBuffer.add(nativeCode);
     nativeBuffer.add(';\n');
 
     void defineInstanceMember(String name, CodeBuffer value) {
       nativeBuffer.add("$className.$name = $value;\n");
     }
 
     classElement.implementation.forEachMember((_, Element member) {
       if (member.isInstanceMember()) {
         emitter.addInstanceMember(member, defineInstanceMember);
       }
     });
   }
 
   bool isNativeLiteral(String quotedName) {
     return identical(quotedName[1], '=');
   }
 
   bool isNativeGlobal(String quotedName) {
     return identical(quotedName[1], '@');
   }
 
-  String toNativeName(ClassElement cls) {
-    String quotedName = cls.nativeName.slowToString();
+  String toNativeTag(ClassElement cls) {
+    String quotedName = cls.nativeTagInfo.slowToString();
     if (isNativeGlobal(quotedName)) {
       // Global object, just be like the other types for now.
       return quotedName.substring(3, quotedName.length - 1);
     } else {
       return quotedName.substring(2, quotedName.length - 1);
     }
   }
 
   void generateNativeClass(ClassElement classElement) {
     nativeClasses.add(classElement);
 
     assert(classElement.backendMembers.isEmpty);
-    String quotedName = classElement.nativeName.slowToString();
+    String quotedName = classElement.nativeTagInfo.slowToString();
     if (isNativeLiteral(quotedName)) {
       generateNativeLiteral(classElement);
       // The native literal kind needs to be dealt with specially when
       // generating code for it.
       return;
     }
 
     CodeBuffer fieldBuffer = new CodeBuffer();
     CodeBuffer getterSetterBuffer = new CodeBuffer();
     CodeBuffer methodBuffer = new CodeBuffer();
 
     emitter.emitClassFields(classElement, fieldBuffer, false);
     emitter.emitClassGettersSetters(classElement, getterSetterBuffer, false);
     emitter.emitInstanceMembers(classElement, methodBuffer, false);
 
     if (methodBuffer.isEmpty
         && fieldBuffer.isEmpty
         && getterSetterBuffer.isEmpty) {
       return;
     }
 
-    String nativeName = toNativeName(classElement);
-    nativeBuffer.add("$defineNativeClassName('$nativeName', ");
+    String nativeTag = toNativeTag(classElement);
+    nativeBuffer.add("$defineNativeClassName('$nativeTag', ");
     nativeBuffer.add('{');
     bool firstInMap = true;
     if (!fieldBuffer.isEmpty) {
       firstInMap = false;
       nativeBuffer.add(fieldBuffer);
     }
     if (!getterSetterBuffer.isEmpty) {
       if (!firstInMap) nativeBuffer.add(",");
       firstInMap = false;
       nativeBuffer.add("\n ");
@@ skipping 57 matching lines @@
     // The target JS function may check arguments.length so we need to
     // make sure not to pass any unspecified optional arguments to it.
     // For example, for the following Dart method:
     //   foo([x, y, z]);
     // The call:
     //   foo(y: 1)
     // must be turned into a JS call to:
     //   foo(null, y).
 
     ClassElement classElement = member.enclosingElement;
-    String nativeTagInfo = classElement.nativeName.slowToString();
+    //String nativeTagInfo = classElement.nativeName.slowToString();
+    String nativeTagInfo = classElement.nativeTagInfo.slowToString();
 
     List<js.Statement> statements = <js.Statement>[];
     potentiallyConvertDartClosuresToJs(statements, member, stubParameters);
 
     String target;
     List<js.Expression> arguments;
 
     if (!nativeMethods.contains(member)) {
       // When calling a method that has a native body, we call it with our
       // calling conventions.
       target = backend.namer.getName(member);
       arguments = argumentsBuffer;
     } else {
       // When calling a JS method, we call it with the native name, and only the
       // arguments up until the last one provided.
-      target = redirectingMethods[member];
-      if (target == null) target = member.name.slowToString();
+      target = member.nativeName();
       arguments = argumentsBuffer.getRange(
           0, indexOfLastOptionalArgumentInParameters + 1);
     }
     statements.add(
         new js.Return(
             new js.VariableUse('this').dot(target).callWith(arguments)));
 
     if (isNativeLiteral(nativeTagInfo) || !overriddenMethods.contains(member)) {
       // Call the method directly.
       return statements;
@@ skipping 100 matching lines @@
     // Expression to compute tags string for a class.  The expression will
     // initially be a string or expression building a string, but may be
     // replaced with a variable reference to the common substring.
     Map<ClassElement, js.Expression> tagDefns =
         new Map<ClassElement, js.Expression>();
 
     js.Expression makeExpression(ClassElement classElement) {
       // Expression fragments for this set of cls keys.
       List<js.Expression> expressions = <js.Expression>[];
       // TODO: Remove if cls is abstract.
-      List<String> subtags = [toNativeName(classElement)];
+      List<String> subtags = [toNativeTag(classElement)];
       void walk(ClassElement cls) {
         for (final ClassElement subclass in getDirectSubclasses(cls)) {
           ClassElement tag = subclass;
           js.Expression existing = tagDefns[tag];
           if (existing == null) {
             // [subclass] is still within the subtree between dispatch classes.
-            subtags.add(toNativeName(tag));
+            subtags.add(toNativeTag(tag));
             walk(subclass);
           } else {
             // [subclass] is one of the preorderDispatchClasses, so CSE this
             // reference with the previous reference.
             if (existing is js.VariableUse &&
                 varDefns.containsKey(existing.name)) {
               // We end up here if the subclasses have a DAG structure.  We
               // don't have DAGs yet, but if the dispatch is used for mixins
               // that will be a possibility.
               // Re-use the previously created temporary variable.
@@ skipping 49 matching lines @@
       }
 
       // [table] is a list of lists, each inner list of the form:
       //   [dynamic-dispatch-tag, tags-of-classes-implementing-dispatch-tag]
       // E.g.
       //   [['Node', 'Text|HTMLElement|HTMLDivElement|...'], ...]
       js.Expression table =
           new js.ArrayInitializer.from(
               preorderDispatchClasses.map((cls) =>
                   new js.ArrayInitializer.from([
-                      new js.LiteralString("'${toNativeName(cls)}'"),
+                      new js.LiteralString("'${toNativeTag(cls)}'"),
                       tagDefns[cls]])));
 
       //  $.dynamicSetMetadata(table);
       statements.add(
           new js.ExpressionStatement(
               new js.Call(
                   new js.VariableUse(dynamicSetMetadataName),
                   [table])));
 
       //  (function(){statements})();
@@ skipping 88 matching lines @@
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }