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);
   }
 
-  List<String> nativeTagsOfClass(ClassElement cls) {
+  bool isNativeGlobal(String quotedName) {
+    return identical(quotedName[1], '@');
+  }
+
+  String toNativeTag(ClassElement cls) {
     String quotedName = cls.nativeTagInfo.slowToString();
-    return quotedName.substring(1, quotedName.length - 1).split(',');
+    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);
+    }
   }
 
   /**
    * 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()) {
-        List<String> nativeTags = nativeTagsOfClass(classElement);
-        if (nativeTags.contains('HTMLElement')) {
+        String nativeTag = toNativeTag(classElement);
+        if (nativeTag == '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) {
-      List<String> nativeTags = nativeTagsOfClass(classElement);
+      String nativeTag = toNativeTag(classElement);
 
       if (nonleafClasses.contains(classElement)) {
         nonleafTags
             .putIfAbsent(classElement, () => new Set<String>())
-            .addAll(nativeTags);
+            .add(nativeTag);
       } else {
         ClassElement sufficingInterceptor = classElement;
         while (!neededClasses.contains(sufficingInterceptor)) {
           sufficingInterceptor = sufficingInterceptor.superclass;
         }
         if (sufficingInterceptor == compiler.objectClass) {
           sufficingInterceptor = backend.jsInterceptorClass;
         }
         leafTags
             .putIfAbsent(sufficingInterceptor, () => new Set<String>())
-            .addAll(nativeTags);
+            .add(nativeTag);
       }
     }
 
     // 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 115 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');
   }
 }