remove dependency on compiler from resolution

pkg/compiler/lib/src/common/backend_api.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.
 
 library dart2js.backend_api;
 
 import 'dart:async' show Future;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenImpact;
 import '../common/resolution.dart' show ResolutionImpact, Frontend, Target;
 import '../compile_time_constants.dart'
     show BackendConstantEnvironment, ConstantCompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart' show ConstantSystem;
 import '../constants/expressions.dart' show ConstantExpression;
 import '../constants/values.dart' show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType;
 import '../elements/elements.dart'
-    show
-        ClassElement,
-        Element,
-        FunctionElement,
-        LibraryElement,
-        MetadataAnnotation,
-        MethodElement;
-import '../enqueue.dart'
-    show Enqueuer, EnqueueTask, CodegenEnqueuer, ResolutionEnqueuer;
+    show ClassElement, Element, FunctionElement, LibraryElement;
+import '../enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
 import '../io/code_output.dart' show CodeBuffer;
 import '../io/source_information.dart' show SourceInformationStrategy;
 import '../js_backend/backend_helpers.dart' as js_backend show BackendHelpers;
 import '../js_backend/js_backend.dart' as js_backend;
 import '../library_loader.dart' show LibraryLoader, LoadedLibraries;
 import '../native/native.dart' as native show NativeEnqueuer, maybeEnableNative;
 import '../patch_parser.dart'
     show checkNativeAnnotation, checkJsInteropAnnotation;
 import '../serialization/serialization.dart'
     show DeserializerPlugin, SerializerPlugin;
-import '../tree/tree.dart' show Node, Send;
-import '../universe/call_structure.dart' show CallStructure;
+import '../tree/tree.dart' show Node;
 import '../universe/world_impact.dart' show ImpactStrategy, WorldImpact;
 import 'codegen.dart' show CodegenWorkItem;
 import 'registry.dart' show Registry;
 import 'tasks.dart' show CompilerTask;
 import 'work.dart' show ItemCompilationContext;
 
 abstract class Backend extends Target {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   /// Returns true if the backend supports reflection.
   bool get supportsReflection;
 
-  /// Returns true if the backend supports reflection.
-  bool get supportsAsyncAwait;
-
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem;
 
   /// The constant environment for the backend interpretation of compile-time
   /// constants.
   BackendConstantEnvironment get constants;
 
   /// The compiler task responsible for the compilation of constants for both
   /// the frontend and the backend.
@@ skipping 154 matching lines @@
       compiler.coreClasses.futureClass;
   ClassElement get asyncStarStreamImplementation =>
       compiler.coreClasses.streamClass;
 
   ClassElement defaultSuperclass(ClassElement element) {
     return compiler.coreClasses.objectClass;
   }
 
   bool isInterceptorClass(ClassElement element) => false;
 
-  /// Returns `true` if [element] is a foreign element, that is, that the
-  /// backend has specialized handling for the element.
-  bool isForeign(Element element) => false;
-
-  /// Returns `true` if [element] is a native element, that is, that the
-  /// corresponding entity already exists in the target language.
-  bool isNative(Element element) => false;
-
   /// Returns `true` if [element] is implemented via typed JavaScript interop.
   // TODO(johnniwinther): Move this to [JavaScriptBackend].
   bool isJsInterop(Element element) => false;
 
   /// Returns `true` if the `native` pseudo keyword is supported for [library].
   bool canLibraryUseNative(LibraryElement library) {
     // TODO(johnniwinther): Move this to [JavaScriptBackend].
     return native.maybeEnableNative(compiler, library);
   }
 
-  /// Processes [element] for resolution and returns the [MethodElement] that
-  /// defines the implementation of [element].
-  MethodElement resolveExternalFunction(MethodElement element) => element;
-
   @override
   bool isTargetSpecificLibrary(LibraryElement library) {
     // TODO(johnniwinther): Remove this when patching is only done by the
     // JavaScript backend.
     Uri canonicalUri = library.canonicalUri;
     if (canonicalUri == js_backend.BackendHelpers.DART_JS_HELPER ||
         canonicalUri == js_backend.BackendHelpers.DART_INTERCEPTORS) {
       return true;
     }
     return false;
@@ skipping 104 matching lines @@
 
   FunctionElement helperForMainArity() => null;
 
   void forgetElement(Element element) {}
 
   void registerMainHasArguments(Enqueuer enqueuer) {}
 
   void registerAsyncMarker(
       FunctionElement element, Enqueuer enqueuer, Registry registry) {}
 
-  /// Called when resolving a call to a foreign function. If a non-null value
-  /// is returned, this is stored as native data for [node] in the resolved
-  /// AST.
-  dynamic resolveForeignCall(Send node, Element element,
-      CallStructure callStructure, ForeignResolver resolver) {}
-
   /// Returns the location of the patch-file associated with [libraryName]
   /// resolved from [plaformConfigUri].
   ///
   /// Returns null if there is none.
   Uri resolvePatchUri(String libraryName, Uri plaformConfigUri);
 
   /// Creates an impact strategy to use for compilation.
   ImpactStrategy createImpactStrategy(
       {bool supportDeferredLoad: true,
       bool supportDumpInfo: true,
@@ skipping 41 matching lines @@
   }
 }
 
 /// Interface for serialization of backend specific data.
 class BackendSerialization {
   const BackendSerialization();
 
   SerializerPlugin get serializer => const SerializerPlugin();
   DeserializerPlugin get deserializer => const DeserializerPlugin();
 }