dart:typed_data type hierarchy changes try 3

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 87 matching lines @@
         const SourceString('defineNativeMethodsExtended'));
     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) {
+  // The tags string contains comma-separated 'words' which are either dispatch
+  // tags (having JavaScript identifier syntax) and directives that begin with
+  // `!`.
+  List<String> nativeTagsOfClassRaw(ClassElement cls) {
     String quotedName = cls.nativeTagInfo.slowToString();
     return quotedName.substring(1, quotedName.length - 1).split(',');
   }
 
+  List<String> nativeTagsOfClass(ClassElement cls) {
+    return nativeTagsOfClassRaw(cls).where((s) => !s.startsWith('!')).toList();
+  }
+
+  bool nativeHasTagsMarker(ClassElement cls, String marker) {
+    return nativeTagsOfClassRaw(cls).contains(marker);
+  }
+
+  bool nativeForcedNonLeaf(ClassElement cls) =>
+      nativeHasTagsMarker(cls, '!nonleaf');
+
   /**
    * 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
    * `Element`.
    *
@@ skipping 67 matching lines @@
         needed = true;
       } else if (neededByConstant.contains(classElement)) {
         needed = true;
       } else if (modifiedClasses.contains(classElement)) {
         // TODO(9556): Remove this test when [emitRuntimeTypeSupport] no longer
         // adds information to a class prototype or constructor.
         needed = true;
       } else if (extensionPoints.containsKey(classElement)) {
         needed = true;
       }
+      if (classElement.isNative() && nativeForcedNonLeaf(classElement)) {
+        needed = true;
+        nonleafClasses.add(classElement);
+      }
 
       if (needed || neededClasses.contains(classElement)) {
         neededClasses.add(classElement);
         neededClasses.add(classElement.superclass);
         nonleafClasses.add(classElement.superclass);
       }
     }
 
     // Collect all the tags that map to each native class.
 
@@ skipping 305 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');
   }
 }