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;
 import '../common/backend_api.dart';
 import '../common/resolution.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         FieldElement,
         LibraryElement,
         MemberElement,
         MetadataAnnotation,
         MethodElement;
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show FunctionElementX, MetadataAnnotationX;
 import '../elements/resolution_types.dart' show ResolutionDartType;
 import '../js_backend/js_backend.dart';
 import '../js_backend/native_data.dart';
+import '../kernel/world_builder.dart' show KernelAnnotationProcessor;
 import '../patch_parser.dart';
 import '../tree/tree.dart';
 import 'behavior.dart';
 
 /// Class that performs the mechanics to investigate annotations in the code.
 abstract class AnnotationProcessor {
   factory AnnotationProcessor(Compiler compiler) =>
       compiler.options.loadFromDill
-          ? new _KernelAnnotationProcessor()
+          // TODO(johnniwinther): Pass the [KernelWorldBuilder] to
+          // [KernelAnnotationProcessor].
+          ? new KernelAnnotationProcessor(null)
           : new _ElementAnnotationProcessor(compiler);
 
   void extractNativeAnnotations(
       LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
 
   void extractJsInteropAnnotations(
       LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
 }
 
-class _KernelAnnotationProcessor implements AnnotationProcessor {
-  void extractNativeAnnotations(
-      LibraryEntity entity, NativeBasicDataBuilder nativeBasicDataBuilder) {
-    throw new UnimplementedError(
-        '_KernelAnnotationProcessor.extractNativeAnnotations');
-  }
-
-  void extractJsInteropAnnotations(
-      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder) {
-    throw new UnimplementedError(
-        '_KernelAnnotationProcessor.extractJsInteropAnnotations');
-  }
-}
-
 /// Original logic for annotation processing, which involves in some cases
 /// triggering pre-parsing and validation of the annotations.
 class _ElementAnnotationProcessor implements AnnotationProcessor {
   Compiler _compiler;
 
   _ElementAnnotationProcessor(this._compiler);
 
   /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
   /// native name from the annotation.
   void extractNativeAnnotations(
@@ skipping 216 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 219 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();
+}