Validate native tags

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 56 matching lines @@
   String get hashCodeHelperName {
     Element element = compiler.findHelper('hashCodeForNativeObject');
     return backend.namer.isolateAccess(element);
   }
 
   String get dispatchPropertyNameVariable {
     Element element = compiler.findInterceptor('dispatchPropertyName');
     return backend.namer.isolateAccess(element);
   }
 
-  // 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;
-    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 72 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)) {
+      if (classElement.isNative() &&
+          native.nativeTagsForcedNonLeaf(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.
 
     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) {
       if (!classElement.isNative()) continue;
-      List<String> nativeTags = nativeTagsOfClass(classElement);
+      List<String> nativeTags = native.nativeTagsOfClass(classElement);
 
       if (nonleafClasses.contains(classElement) ||
           extensionPoints.containsKey(classElement)) {
         nonleafTags
             .putIfAbsent(classElement, () => new Set<String>())
             .addAll(nativeTags);
       } else {
         ClassElement sufficingInterceptor = classElement;
         while (!neededClasses.contains(sufficingInterceptor)) {
           sufficingInterceptor = sufficingInterceptor.superclass;
@@ skipping 290 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');
   }
 }