Add NativeDataResolver

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 394 matching lines @@
 
   /**
    * Try to inline [element] within the correct context of the builder. The
    * insertion point is the state of the builder.
    */
   bool tryInlineMethod(MethodElement element, Selector selector, TypeMask mask,
       List<HInstruction> providedArguments, ast.Node currentNode,
       {ResolutionInterfaceType instanceType}) {
     registry.registerStaticUse(new StaticUse.inlining(element));
 
-    if (backend.nativeData.isJsInterop(element) &&
+    if (backend.nativeData.isJsInteropMember(element) &&
         !element.isFactoryConstructor) {
       // We only inline factory JavaScript interop constructors.
       return false;
     }
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
 
     if (compiler.elementHasCompileTimeError(element)) return false;
 
@@ skipping 16 matching lines @@
               Elements.isStaticOrTopLevel(function) ||
               function.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $function."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
-      if (backend.nativeData.isJsInterop(function)) return false;
+      if (backend.nativeData.isJsInteropMember(function)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (function.name == '==') {
         if (function.enclosingClass != commonElements.objectClass &&
             providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
@@ skipping 223 matching lines @@
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(MethodElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = closedWorld.isCalledInLoop(functionElement);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
-    if (backend.nativeData.isJsInterop(functionElement)) {
+    if (backend.nativeData.isJsInteropMember(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
     assert(invariant(functionElement, !function.modifiers.isExternal));
 
     // If [functionElement] is `operator==` we explicitly add a null check at
@@ skipping 466 matching lines @@
    *    to, starting from the current constructor.
    *  - Call the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
    */
   HGraph buildFactory(ResolvedAst resolvedAst) {
     ConstructorElement functionElement = resolvedAst.element;
     functionElement = functionElement.implementation;
     ClassElement classElement = functionElement.enclosingClass.implementation;
     bool isNativeUpgradeFactory =
         backend.nativeData.isNativeOrExtendsNative(classElement) &&
-            !backend.nativeData.isJsInterop(classElement);
+            !backend.nativeData.isJsInteropClass(classElement);
     ast.FunctionExpression function;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       function = resolvedAst.node;
     }
 
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
@@ skipping 1309 matching lines @@
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
     return Elements.makeArgumentsList<HInstruction>(
         callStructure,
         arguments,
         element,
         compileArgument,
-        backend.nativeData.isJsInterop(element)
+        backend.nativeData.isJsInteropMember(element)
             ? handleConstantForOptionalParameterJsInterop
             : handleConstantForOptionalParameter);
   }
 
   void addGenericSendArgumentsToList(
       Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
@@ skipping 873 matching lines @@
     if (constructorImplementation.isMalformed ||
         !callStructure.signatureApplies(constructorImplementation.type)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         backend.nativeData
             .isNativeOrExtendsNative(constructor.enclosingClass) &&
-        !backend.nativeData.isJsInterop(constructor)) {
+        !backend.nativeData.isJsInteropMember(constructor)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(closedWorld));
     }
     inputs.addAll(makeStaticArgumentList(
         callStructure, send.arguments, constructorImplementation));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(closedWorld)) {
         HTypeConversion conversion = new HTypeConversion(
@@ skipping 586 matching lines @@
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type)
         ..sourceInformation = sourceInformation);
     } else {
       push(new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
         ..sourceInformation = sourceInformation);
     }
   }
 
   HForeignCode invokeJsInteropFunction(MethodElement element,
       List<HInstruction> arguments, SourceInformation sourceInformation) {
-    assert(backend.nativeData.isJsInterop(element));
+    assert(backend.nativeData.isJsInteropMember(element));
     nativeEmitter.nativeMethods.add(element);
 
     if (element.isFactoryConstructor &&
         backend.jsInteropAnalysis
             .hasAnonymousAnnotation(element.contextClass)) {
       // Factory constructor that is syntactic sugar for creating a JavaScript
       // object literal.
       ConstructorElement constructor = element;
       FunctionSignature params = constructor.functionSignature;
       int i = 0;
@@ skipping 97 matching lines @@
       return;
     }
 
     if (typeMask == null) {
       typeMask = TypeMaskFactory.inferredReturnTypeForElement(
           element, globalInferenceResults);
     }
     bool targetCanThrow = !closedWorld.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
-    if (backend.nativeData.isJsInterop(element)) {
+    if (backend.nativeData.isJsInteropMember(element)) {
       instruction =
           invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
       instruction = new HInvokeStatic(element, arguments, typeMask,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (currentInlinedInstantiations.isNotEmpty) {
         instruction.instantiatedTypes =
             new List<ResolutionDartType>.from(currentInlinedInstantiations);
@@ skipping 2585 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }