Split NativeData

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 395 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.addImpact(
         backend.codegenEnqueuerListener.registerUsedElement(element));
 
-    if (backend.isJsInterop(element) && !element.isFactoryConstructor) {
+    if (backend.nativeData.isJsInterop(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;
 
     MethodElement function = element;
@@ skipping 15 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.isJsInterop(function)) return false;
+      if (backend.nativeData.isJsInterop(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.isJsInterop(functionElement)) {
+    if (backend.nativeData.isJsInterop(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.isJsInterop(classElement);
+            !backend.nativeData.isJsInterop(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.isJsInterop(element)
+        backend.nativeData.isJsInterop(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 783 matching lines @@
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred = _inferredTypeOfNewList(send);
         return inferred.containsAll(closedWorld)
             ? commonMasks.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
           originalElement, closedWorld)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         ClassElement cls = element.enclosingClass;
-        assert(backend.isNative(cls.thisType.element));
+        assert(backend.nativeData.isNativeClass(cls));
         return inferred.containsAll(closedWorld)
-            ? new TypeMask.nonNullExact(cls.thisType.element, closedWorld)
+            ? new TypeMask.nonNullExact(cls, closedWorld)
             : inferred;
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
         if (cls.isAbstract) {
           // An error will be thrown.
           return new TypeMask.nonNullEmpty();
         } else {
-          return new TypeMask.nonNullExact(cls.thisType.element, closedWorld);
+          return new TypeMask.nonNullExact(cls, closedWorld);
         }
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, globalInferenceResults);
       }
     }
 
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
     ConstructorElement constructorImplementation = constructor.implementation;
@@ skipping 59 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.isJsInterop(constructor)) {
+        !backend.nativeData.isJsInterop(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.isJsInterop(element));
+    assert(backend.nativeData.isJsInterop(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 48 matching lines @@
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
     nativeBehavior.typesReturned.add(
         compiler.options.trustJSInteropTypeAnnotations
             ? type
             : const ResolutionDynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
-    if (type.element != null && backend.isNative(type.element)) {
+    if (type is ResolutionInterfaceType &&
+        backend.nativeData.isNativeClass(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!compiler.options.trustJSInteropTypeAnnotations ||
         type.isObject ||
         type.isDynamic) {
       ClassElement cls = backend.helpers.jsJavaScriptObjectClass;
       nativeBehavior.typesInstantiated.add(cls.thisType);
@@ skipping 27 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.isJsInterop(element)) {
+    if (backend.nativeData.isJsInterop(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);
 }