Move native and js interop properties from the element model to the JS backend

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 422 matching lines @@
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     SourceInformation source = sourceInformationBuilder.buildReturn(node);
     if (node.beginToken.value == 'native') {
       FunctionElement function = irBuilder.state.currentElement;
-      assert(function.isNative);
+      assert(compiler.backend.isNative(function));
       ast.Node nativeBody = node.expression;
       if (nativeBody != null) {
         ast.LiteralString jsCode = nativeBody.asLiteralString();
         String javaScriptCode = jsCode.dartString.slowToString();
         assert(invariant(nativeBody,
             !nativeRedirectionRegExp.hasMatch(javaScriptCode),
           message: "Deprecated syntax, use @JSName('name') instead."));
         assert(invariant(nativeBody,
             function.functionSignature.parameterCount == 0,
             message: 'native "..." syntax is restricted to '
               'functions with zero parameters.'));
         irBuilder.buildNativeFunctionBody(function, javaScriptCode);
       } else {
-        irBuilder.buildRedirectingNativeFunctionBody(function, source);
+        JavaScriptBackend backend = compiler.backend;
+        String name = backend.getFixedBackendName(function);
+        irBuilder.buildRedirectingNativeFunctionBody(function, name, source);
       }
     } else {
       irBuilder.buildReturn(
           value: build(node.expression),
           sourceInformation: source);
     }
   }
 
   visitSwitchStatement(ast.SwitchStatement node) {
     assert(irBuilder.isOpen);
@@ skipping 2317 matching lines @@
       // The initial value of all fields are now bound in [fieldValues].
 
       // --- Create the object ---
       // Get the initial field values in the canonical order.
       List<ir.Primitive> instanceArguments = <ir.Primitive>[];
       classElement.forEachInstanceField((ClassElement c, FieldElement field) {
         ir.Primitive value = fieldValues[field];
         if (value != null) {
           instanceArguments.add(value);
         } else {
-          assert(Elements.isNativeOrExtendsNative(c));
+          assert(backend.isNativeOrExtendsNative(c));
           // Native fields are initialized elsewhere.
         }
       }, includeSuperAndInjectedMembers: true);
 
       ir.Primitive instance = new ir.CreateInstance(
           classElement,
           instanceArguments,
           typeInformation,
           constructor.hasNode
               ? sourceInformationBuilder.buildCreate(constructor.node)
@@ skipping 44 matching lines @@
     assert(constructor == elements.analyzedElement);
     ClassElement enclosingClass = constructor.enclosingClass.implementation;
     // Evaluate declaration-site field initializers, unless this constructor
     // redirects to another using a `this()` initializer. In that case, these
     // will be initialized by the effective target constructor.
     if (!constructor.isRedirectingGenerative) {
       enclosingClass.forEachInstanceField((ClassElement c, FieldElement field) {
         if (field.initializer != null) {
           fieldValues[field] = inlineExpression(field, field.initializer);
         } else {
-          if (Elements.isNativeOrExtendsNative(c)) {
+          if (backend.isNativeOrExtendsNative(c)) {
             // Native field is initialized elsewhere.
           } else {
             // Fields without an initializer default to null.
             // This value will be overwritten below if an initializer is found.
             fieldValues[field] = irBuilder.buildNullConstant();
           }
         }
       });
     }
     // If this is a mixin constructor, it does not have its own parameter list
@@ skipping 705 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }