Compute NativeBasicData for KernelWorldBuilder

pkg/compiler/lib/src/native/resolver.dart

 // Copyright (c) 2014, 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.
 
 import 'package:front_end/src/fasta/scanner.dart'
     show BeginGroupToken, StringToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements;
@@ skipping 208 matching lines @@
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
   }
 
   /// Returns the JSName annotation string or `null` if no JSName annotation is
   /// present.
   String _findJsNameFromAnnotation(Element element) {
-    String name = null;
-    ClassElement annotationClass =
-        _compiler.commonElements.annotationJSNameClass;
+    String jsName = null;
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(_compiler.resolution);
       ConstantValue value =
           _compiler.constants.getConstantValue(annotation.constant);
-      if (!value.isConstructedObject) continue;
-      ConstructedConstantValue constructedObject = value;
-      if (constructedObject.type.element != annotationClass) continue;
-
-      Iterable<ConstantValue> fields = constructedObject.fields.values;
-      // TODO(sra): Better validation of the constant.
-      if (fields.length != 1 || fields.single is! StringConstantValue) {
-        _reporter.internalError(
-            annotation, 'Annotations needs one string: ${annotation}');
-      }
-      StringConstantValue specStringConstant = fields.single;
-      String specString = specStringConstant.toDartString().slowToString();
-      if (name == null) {
-        name = specString;
-      } else {
-        _reporter.internalError(
+      String name = readAnnotationName(
+          annotation, value, _compiler.commonElements.annotationJSNameClass);
+      if (jsName == null) {
+        jsName = name;
+      } else if (name != null) {
+        throw new SpannableAssertionFailure(
             annotation, 'Too many JSName annotations: ${annotation}');
       }
     }
-    return name;
+    return jsName;
   }
 
   @override
   NativeBehavior resolveJsCall(Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsCallSend(node, _reporter,
         _compiler.parsingContext, _compiler.commonElements, resolver);
   }
 
   @override
   NativeBehavior resolveJsEmbeddedGlobalCall(
@@ skipping 35 matching lines @@
     }
     return null;
   }
 
   String apply(
       Compiler compiler, Element element, MetadataAnnotation annotation) {
     if (element.isClass) {
       ClassElement cls = element;
       String native = getNativeAnnotation(annotation);
       if (native != null) {
-        _nativeBasicDataBuilder.setNativeClassTagInfo(cls, native);
+        String tagText = native.substring(1, native.length - 1);
+        _nativeBasicDataBuilder.setNativeClassTagInfo(cls, tagText);
         return native;
       }
     }
     return null;
   }
 
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant) {
     ResolutionDartType annotationType =
         constant.getType(compiler.commonElements);
@@ skipping 239 matching lines @@
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.lexeme;
     }
 
     return _reporter.withCurrentElement(classElement, () {
       return scanForExtendsName(classElement.position);
     });
   }
 }
+
+/// Extracts the name if [value] is a named annotation based on
+/// [annotationClass], otherwise returns `null`.
+String readAnnotationName(
+    Spannable spannable, ConstantValue value, ClassEntity annotationClass) {
+  if (!value.isConstructedObject) return null;
+  ConstructedConstantValue constructedObject = value;
+  if (constructedObject.type.element != annotationClass) return null;
+
+  Iterable<ConstantValue> fields = constructedObject.fields.values;
+  // TODO(sra): Better validation of the constant.
+  if (fields.length != 1 || fields.single is! StringConstantValue) {
+    throw new SpannableAssertionFailure(
+        spannable, 'Annotations needs one string: ${value.toStructuredText()}');
+  }
+  StringConstantValue specStringConstant = fields.single;
+  return specStringConstant.toDartString().slowToString();
+}