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

pkg/compiler/lib/src/elements/elements.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 elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show
     Resolution;
 import '../compiler.dart' show
@@ skipping 287 matching lines @@
   bool get isInstanceMember;
 
   /// Returns true if this [Element] is a top level element.
   /// That is, if it is not defined within the scope of a class.
   ///
   /// This means whether the enclosing element is a compilation unit.
   /// With the exception of [ClosureClassElement] that is considered top level
   /// as all other classes.
   bool get isTopLevel;
   bool get isAssignable;
-  bool get isNative;
-  bool get isJsInterop;
 
   bool get isDeferredLoaderGetter;
 
   /// True if the element is declared in a patch library but has no
   /// corresponding declaration in the origin library.
   bool get isInjected;
 
   /// `true` if this element is a constructor, top level or local variable,
   /// or static field that is declared `const`.
   bool get isConst;
@@ skipping 74 matching lines @@
   Element get patch;
 
   /// Returns the origin for this element if this element is a patch.
   ///
   /// See [:patch_parser.dart:] for a description of the terminology.
   Element get origin;
 
   bool get isSynthesized;
   bool get isMixinApplication;
 
-  bool get hasFixedBackendName;
-  String get fixedBackendName;
-
-  String get jsInteropName;
-
   bool get isAbstract;
 
   Scope buildScope();
 
   // TODO(johnniwinther): Move this to [AstElement].
   /// Returns the [Element] that holds the [TreeElements] for this element.
   AnalyzableElement get analyzableElement;
 
   accept(ElementVisitor visitor, arg);
-
-  void setJsInteropName(String name);
-  void markAsJsInterop();
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
     return e == null || e.isErroneous;
   }
   static bool isErroneous(Element e) => e != null && e.isErroneous;
 
   /// Unwraps [element] reporting any warnings attached to it, if any.
   static Element unwrap(Element element,
@@ skipping 82 matching lines @@
   static bool isNonAbstractInstanceMember(Element element) {
     // The generative constructor body is not a function. We therefore treat
     // it specially.
     if (element.isGenerativeConstructorBody) return true;
     return !Elements.isUnresolved(element) &&
         !element.isAbstract &&
         element.isInstanceMember &&
         (element.isFunction || element.isAccessor);
   }
 
-  static bool isNativeOrExtendsNative(ClassElement element) {
-    if (element == null) return false;
-    if (element.isNative || element.isJsInterop) return true;
-    assert(element.isResolved);
-    return isNativeOrExtendsNative(element.superclass);
-  }
-
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element == null) return !isClosureSend(send, element);
     return isInstanceMethod(element) ||
            isInstanceField(element) ||
            (send.isConditional && !element.isStatic);
   }
 
   static bool isClosureSend(Send send, Element element) {
     if (send.isPropertyAccess) return false;
@@ skipping 199 matching lines @@
   }
 
   static bool isConstructorOfTypedArraySubclass(Element element,
                                                 Compiler compiler) {
     if (compiler.typedDataLibrary == null) return false;
     if (!element.isConstructor) return false;
     ConstructorElement constructor = element.implementation;
     constructor = constructor.effectiveTarget;
     ClassElement cls = constructor.enclosingClass;
     return cls.library == compiler.typedDataLibrary
-        && cls.isNative
+        && compiler.backend.isNative(cls)
         && compiler.world.isSubtypeOf(cls, compiler.typedDataClass)
         && compiler.world.isSubtypeOf(cls, compiler.listClass)
         && constructor.name == '';
   }
 
   static bool switchStatementHasContinue(SwitchStatement node,
                                          TreeElements elements) {
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         Node label = labelOrCase.asLabel();
@@ skipping 137 matching lines @@
    * the scheme 'package'.
    */
   bool get isPackageLibrary;
 
   /**
    * [:true:] if this library is a platform library whose path starts with
    * an underscore.
    */
   bool get isInternalLibrary;
 
-  bool get canUseNative;
   bool get exportsHandled;
 
   LibraryElement get implementation;
 
   Element find(String elementName);
   Element findLocal(String elementName);
   Element findExported(String elementName);
   void forEachExport(f(Element element));
 
   /// Calls [f] for each [Element] imported into this library.
@@ skipping 469 matching lines @@
   Link<DartType> get interfaces;
 
   bool get hasConstructor;
   Link<Element> get constructors;
 
   ClassElement get patch;
   ClassElement get origin;
   ClassElement get declaration;
   ClassElement get implementation;
 
-  String get nativeTagInfo;
-
   /// `true` if this class is an enum declaration.
   bool get isEnumClass;
 
   /// `true` if this class is a mixin application, either named or unnamed.
   bool get isMixinApplication;
 
   /// `true` if this class is a named mixin application, e.g.
   ///
   ///     class NamedMixinApplication = SuperClass with MixinClass;
   ///
@@ skipping 301 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }