Remove Compiler.commonElements

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 StringToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 import 'package:front_end/src/scanner/token.dart' show BeginToken;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
@@ skipping 200 matching lines @@
 
 class NativeDataResolverImpl extends NativeMemberResolverBase
     implements NativeDataResolver {
   final Compiler _compiler;
 
   NativeDataResolverImpl(this._compiler);
 
   JavaScriptBackend get _backend => _compiler.backend;
   DiagnosticReporter get _reporter => _compiler.reporter;
   ElementEnvironment get elementEnvironment => _compiler.elementEnvironment;
-  CommonElements get commonElements => _compiler.commonElements;
+  CommonElements get commonElements => _compiler.resolution.commonElements;
   NativeBasicData get nativeBasicData => _backend.nativeBasicData;
   NativeDataBuilder get nativeDataBuilder => _backend.nativeDataBuilder;
 
   @override
   bool isJsInteropMember(MemberElement element) {
     // TODO(johnniwinther): Avoid computing this twice for external function;
     // once from JavaScriptBackendTarget.resolveExternalFunction and once
     // through JavaScriptBackendTarget.resolveNativeMember.
     bool isJsInterop =
         checkJsInteropMemberAnnotations(_compiler, element, nativeDataBuilder);
@@ skipping 54 matching lines @@
   @override
   bool _processFieldAnnotations(FieldElement element) {
     if (_compiler.serialization.isDeserialized(element)) {
       return false;
     }
     return super._processFieldAnnotations(element);
   }
 
   @override
   NativeBehavior resolveJsCall(Send node, ForeignResolver resolver) {
-    return NativeBehavior.ofJsCallSend(node, _reporter,
-        _compiler.parsingContext, _compiler.commonElements, resolver);
+    return NativeBehavior.ofJsCallSend(
+        node, _reporter, _compiler.parsingContext, commonElements, resolver);
   }
 
   @override
   NativeBehavior resolveJsEmbeddedGlobalCall(
       Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsEmbeddedGlobalCallSend(
-        node, _reporter, _compiler.commonElements, resolver);
+        node, _reporter, commonElements, resolver);
   }
 
   @override
   NativeBehavior resolveJsBuiltinCall(Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsBuiltinCallSend(
-        node, _reporter, _compiler.commonElements, resolver);
+        node, _reporter, commonElements, resolver);
   }
 }
 
 /// Annotation handler for pre-resolution detection of `@Native(...)`
 /// annotations.
 class NativeAnnotationHandler extends EagerAnnotationHandler<String> {
   final NativeBasicDataBuilder _nativeBasicDataBuilder;
 
   NativeAnnotationHandler(this._nativeBasicDataBuilder);
 
@@ skipping 19 matching lines @@
         _nativeBasicDataBuilder.setNativeClassTagInfo(cls, tagText);
         return native;
       }
     }
     return null;
   }
 
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant) {
     ResolutionDartType annotationType =
-        constant.getType(compiler.commonElements);
+        constant.getType(compiler.resolution.commonElements);
     if (annotationType.element !=
-        compiler.commonElements.nativeAnnotationClass) {
+        compiler.resolution.commonElements.nativeAnnotationClass) {
       DiagnosticReporter reporter = compiler.reporter;
       reporter.internalError(annotation, 'Invalid @Native(...) annotation.');
     }
   }
 }
 
 bool checkJsInteropMemberAnnotations(Compiler compiler, MemberElement element,
     NativeDataBuilder nativeDataBuilder) {
   bool isJsInterop = EagerAnnotationHandler.checkAnnotation(
       compiler, element, const JsInteropAnnotationHandler());
@@ skipping 13 matching lines @@
       annotation.beginToken.next.lexeme == 'JS';
 
   bool apply(
       Compiler compiler, Element element, MetadataAnnotation annotation) {
     return hasJsNameAnnotation(annotation);
   }
 
   @override
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant) {
-    ResolutionDartType type = constant.getType(compiler.commonElements);
-    if (type.element != compiler.commonElements.jsAnnotationClass) {
+    ResolutionDartType type =
+        constant.getType(compiler.resolution.commonElements);
+    if (type.element != compiler.resolution.commonElements.jsAnnotationClass) {
       compiler.reporter
           .internalError(annotation, 'Invalid @JS(...) annotation.');
     }
   }
 
   bool get defaultResult => false;
 }
 
 /// Determines all native classes in a set of libraries.
 abstract class NativeClassFinder {
@@ skipping 217 matching lines @@
 
   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.primitiveValue;
 }