Refactor resolution of foreign calls.

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 '../compiler.dart' show
     Compiler;
 import '../compile_time_constants.dart' show
     BackendConstantEnvironment,
     ConstantCompilerTask;
+import '../constants/expressions.dart' show
+    ConstantExpression;
 import '../constants/constant_system.dart' show
     ConstantSystem;
 import '../constants/values.dart' show
     ConstantValue;
 import '../dart_types.dart' show
     DartType,
     InterfaceType;
 import '../diagnostics/spannable.dart' show
     Spannable,
     SpannableAssertionFailure;
@@ skipping 17 matching lines @@
     JavaScriptBackend;
 import '../library_loader.dart' show
     LibraryLoader,
     LoadedLibraries;
 import '../native/native.dart' as native show
     NativeEnqueuer;
 import '../patch_parser.dart' show
     checkNativeAnnotation;
 import '../resolution/tree_elements.dart' show
     TreeElements;
+import '../tree/tree.dart' show
+    Node,
+    Send;
+import '../universe/call_structure.dart' show
+    CallStructure;
 
 import 'codegen.dart' show
     CodegenWorkItem;
 import 'registry.dart' show
     Registry;
 import 'resolution.dart' show
     ResolutionCallbacks;
 import 'tasks.dart' show
     CompilerTask;
 import 'work.dart' show
@@ skipping 307 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.
+  void registerForeignCall(Send node,
+                           Element element,
+                           CallStructure callStructure,
+                           ForeignResolver resolver) {}
 }
 
+/// Interface for resolving calls to foreign functions.
+abstract class ForeignResolver {
+  /// Returns the constant expression of [node], or `null` if [node] is not
+  /// a constant expression.
+  ConstantExpression getConstant(Node node);
+
+  /// Registers [type] as instantiated.
+  void registerInstantiatedType(InterfaceType type);
+
+  /// Resolves [typeName] to a type in the context of [node].
+  DartType resolveTypeFromString(Node node, String typeName);
+}