Support user generated custom native JS classes.

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 '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 282 matching lines @@
 
   /// 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 87 matching lines @@
 
   Scope buildScope();
 
   void diagnose(Element context, DiagnosticListener listener);
 
   // TODO(johnniwinther): Move this to [AstElement].
   /// Returns the [Element] that holds the [TreeElements] for this element.
   AnalyzableElement get analyzableElement;
 
   accept(ElementVisitor visitor, arg);
+
+  void setJsInterop(String name);
 }
 
 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 84 matching lines @@
     // 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) return true;
+    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);
@@ skipping 1128 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;
 }