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

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 619 matching lines @@
 
   /// Annotated name for [method] encoding arity and named parameters.
   jsAst.Name instanceMethodName(FunctionElement method) {
     if (method.isGenerativeConstructorBody) {
       return constructorBodyName(method);
     }
     return invocationName(new Selector.fromElement(method));
   }
 
   String _jsNameHelper(Element e) {
-    if (e.jsInteropName != null && e.jsInteropName.isNotEmpty)
-      return e.jsInteropName;
+    String jsInteropName = backend.getJsInteropName(e);
+    if (jsInteropName != null && jsInteropName.isNotEmpty)
+      return jsInteropName;
     return e.isLibrary ? 'self' : e.name;
   }
 
   /// Returns a JavaScript path specifying the context in which
   /// [element.fixedBackendName] should be evaluated. Only applicable for
   /// elements using typed JavaScript interop.
   /// For example: fixedBackendPath for the static method createMap in the
   /// Map class of the goog.map JavaScript library would have path
   /// "goog.maps.Map".
   String fixedBackendPath(Element element) {
-    if (!element.isJsInterop) return null;
+    if (!backend.isJsInterop(element)) return null;
     if (element.isInstanceMember) return 'this';
     if (element.isConstructor) return fixedBackendPath(element.enclosingClass);
     if (element.isLibrary) return 'self';
     var sb = new StringBuffer();
     sb..write(_jsNameHelper(element.library));
 
     if (element.enclosingClass != null && element.enclosingClass != element) {
       sb..write('.')..write(_jsNameHelper(element.enclosingClass));
     }
     return sb.toString();
@@ skipping 121 matching lines @@
   jsAst.Name globalPropertyName(Element element) {
     return _disambiguateGlobal(element);
   }
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
   jsAst.Name instanceFieldPropertyName(FieldElement element) {
     ClassElement enclosingClass = element.enclosingClass;
 
-    if (element.hasFixedBackendName) {
-      return new StringBackedName(element.fixedBackendName);
+    if (backend.hasFixedBackendName(element)) {
+      return new StringBackedName(backend.getFixedBackendName(element));
     }
 
     // Instances of BoxFieldElement are special. They are already created with
     // a unique and safe name. However, as boxes are not really instances of
     // classes, the usual naming scheme that tries to avoid name clashes with
     // super classes does not apply. We still do not mark the name as a
     // fixedBackendName, as we want to allow other namers to do something more
     // clever with them.
     if (element is BoxFieldElement) {
       return new StringBackedName(element.name);
@@ skipping 19 matching lines @@
     // the field name would have to be mangled.
     return _disambiguateMember(element.memberName);
   }
 
   bool _isShadowingSuperField(Element element) {
     return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassElement class_) {
-    return !class_.isNative &&
-           Elements.isNativeOrExtendsNative(class_.superclass);
+    return !backend.isNative(class_) &&
+           backend.isNativeOrExtendsNative(class_.superclass);
   }
 
   /// Annotated name for the setter of [element].
   jsAst.Name setterForElement(MemberElement element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
@@ skipping 362 matching lines @@
       if (cls == backend.jsArrayClass) return "a";
       if (cls == backend.jsDoubleClass) return "d";
       if (cls == backend.jsIntClass) return "i";
       if (cls == backend.jsNumberClass) return "n";
       if (cls == backend.jsNullClass) return "u";
       if (cls == backend.jsBoolClass) return "b";
       if (cls == backend.jsInterceptorClass) return "I";
       return cls.name;
     }
     List<String> names = classes
-        .where((cls) => !Elements.isNativeOrExtendsNative(cls))
+        .where((cls) => !backend.isNativeOrExtendsNative(cls))
         .map(abbreviate)
         .toList();
     // There is one dispatch mechanism for all native classes.
-    if (classes.any((cls) => Elements.isNativeOrExtendsNative(cls))) {
+    if (classes.any((cls) => backend.isNativeOrExtendsNative(cls))) {
       names.add("x");
     }
     // Sort the names of the classes after abbreviating them to ensure
     // the suffix is stable and predictable for the suggested names.
     names.sort();
     return names.join();
   }
 
   /// Property name used for `getInterceptor` or one of its specializations.
   jsAst.Name nameForGetInterceptor(Iterable<ClassElement> classes) {
@@ skipping 788 matching lines @@
       }
     }
   }
 }
 
 enum NamingScope {
   global,
   instance,
   constant
 }