Revert "Revert "Allow multiple tags in native clause.""

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 81 matching lines @@
         const SourceString('defineNativeMethodsNonleaf'));
     return backend.namer.isolateAccess(element);
   }
 
   String get defineNativeMethodsFinishName {
     Element element = compiler.findHelper(
         const SourceString('defineNativeMethodsFinish'));
     return backend.namer.isolateAccess(element);
   }
 
-  bool isNativeGlobal(String quotedName) {
-    return identical(quotedName[1], '@');
-  }
-
-  String toNativeTag(ClassElement cls) {
+  List<String> nativeTagsOfClass(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);
-    }
+    return quotedName.substring(1, quotedName.length - 1).split(',');
   }
 
   /**
    * Writes the class definitions for the interceptors to [mainBuffer].
    * Writes code to associate dispatch tags with interceptors to [nativeBuffer].
    *
    * The interceptors are filtered to avoid emitting trivial interceptors.  For
    * example, if the program contains no code that can distinguish between the
    * numerous subclasses of `Element` then we can pretend that `Element` is a
    * leaf class, and all instances of subclasses of `Element` are instances of
@@ skipping 54 matching lines @@
         // TODO(9556): We can't remove any unneeded classes until the class
         // builders contain all the information.  [emitRuntimeTypeSupport] must
         // no longer add information to a class definition.
         needed = true;
       }
 
       // BUG.  There is a missing proto in the picture the DOM gives of the
       // proto chain.
       // TODO(9907): Fix DOM generation. We might need an annotation.
       if (classElement.isNative()) {
-        String nativeTag = toNativeTag(classElement);
-        if (nativeTag == 'HTMLElement') {
+        List<String> nativeTags = nativeTagsOfClass(classElement);
+        if (nativeTags.contains('HTMLElement')) {
           nonleafClasses.add(classElement);
           needed = true;
         }
       }
 
       if (needed || neededClasses.contains(classElement)) {
         neededClasses.add(classElement);
         neededClasses.add(classElement.superclass);
         nonleafClasses.add(classElement.superclass);
       }
     }
 
     // Collect all the tags that map to each class.
 
     Map<ClassElement, Set<String>> leafTags =
         new Map<ClassElement, Set<String>>();
     Map<ClassElement, Set<String>> nonleafTags =
         new Map<ClassElement, Set<String>>();
 
     for (ClassElement classElement in classes) {
-      String nativeTag = toNativeTag(classElement);
+      List<String> nativeTags = nativeTagsOfClass(classElement);
 
       if (nonleafClasses.contains(classElement)) {
         nonleafTags
             .putIfAbsent(classElement, () => new Set<String>())
-            .add(nativeTag);
+            .addAll(nativeTags);
       } else {
         ClassElement sufficingInterceptor = classElement;
         while (!neededClasses.contains(sufficingInterceptor)) {
           sufficingInterceptor = sufficingInterceptor.superclass;
         }
         if (sufficingInterceptor == compiler.objectClass) {
           sufficingInterceptor = backend.jsInterceptorClass;
         }
         leafTags
             .putIfAbsent(sufficingInterceptor, () => new Set<String>())
-            .add(nativeTag);
+            .addAll(nativeTags);
       }
     }
 
     // Emit code to set up dispatch data that maps tags to the interceptors.
 
     void generateDefines(ClassElement classElement) {
       generateDefineNativeMethods(leafTags[classElement], classElement,
           defineNativeMethodsName);
       generateDefineNativeMethods(nonleafTags[classElement], classElement,
           defineNativeMethodsNonleafName);
@@ skipping 46 matching lines @@
     if (!hasFields && builder.properties.length == propertyCount) {
       builder.isTrivial = true;
     }
 
     return builder;
   }
 
   void generateDefineNativeMethods(
       Set<String> tags, ClassElement classElement, String definer) {
     if (tags == null) return;
-
     String tagsString = (tags.toList()..sort()).join('|');
     jsAst.Expression definition =
         js(definer)(
             [js.string(tagsString),
              js(backend.namer.isolateAccess(classElement))]);
 
     nativeBuffer.add(jsAst.prettyPrint(definition, compiler));
     nativeBuffer.add('$N$n');
   }
 
@@ skipping 48 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.nativeTagInfo.slowToString();
 
     List<jsAst.Statement> statements = <jsAst.Statement>[];
     potentiallyConvertDartClosuresToJs(statements, member, stubParameters);
 
     String target;
     jsAst.Expression receiver;
     List<jsAst.Expression> arguments;
 
     if (!nativeMethods.contains(member)) {
       // When calling a method that has a native body, we call it with our
@@ skipping 85 matching lines @@
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }