Support for extending native classes

sdk/lib/_internal/compiler/implementation/js_backend/backend.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.
 
 part of js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 182 matching lines @@
   Element jsStringConcat;
   Element jsStringToString;
   Element objectEquals;
 
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
 
   Element getInterceptorMethod;
   Element interceptedNames;
+  /**

[ahe, 2013/08/13 18:31:47]

Add newline before comment.

[sra1, 2013/08/14 04:36:47]

Done.

+   * This element is a top-level variable that the compiler initializes to a

[ahe, 2013/08/13 18:31:47]

Consider:

... top-level variable (in generated output) that ...

[sra1, 2013/08/14 04:36:47]

Done.

+   * datastructure used to map from a Type to the interceptor.  See declaration
+   * of `mapTypeToInterceptor` in `interceptors.dart`.
+   */
+  Element mapTypeToInterceptor;
 
   HType stringType;
   HType indexablePrimitiveType;
   HType readableArrayType;
   HType mutableArrayType;
   HType fixedArrayType;
   HType extendableArrayType;
 
   // TODO(9577): Make it so that these are not needed when there are no native
   // classes.
@@ skipping 136 matching lines @@
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
   bool isInterceptorClass(ClassElement element) {
     if (element == null) return false;
-    if (element.isNative()) return true;
+    if (Elements.isNativeOrExtendsNative(element)) return true;
     if (interceptedClasses.contains(element)) return true;
     if (classesMixedIntoNativeClasses.contains(element)) return true;
     return false;
   }
 
   String registerOneShotInterceptor(Selector selector) {
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
     String name = namer.getOneShotInterceptorName(selector, classes);
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
@@ skipping 35 matching lines @@
    */
   Set<ClassElement> getInterceptedClassesOn(SourceString name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
     return interceptedClassesCache.putIfAbsent(name, () {
       // Populate the cache by running through all the elements and
       // determine if the given selector applies to them.
       Set<ClassElement> result = new Set<ClassElement>();
       for (Element element in intercepted) {
         ClassElement classElement = element.getEnclosingClass();
-        if (classElement.isNative()
+        if (Elements.isNativeOrExtendsNative(classElement)
             || interceptedClasses.contains(classElement)) {
           result.add(classElement);
         }
         if (classesMixedIntoNativeClasses.contains(classElement)) {
           Set<ClassElement> nativeSubclasses =
               nativeSubclassesOfMixin(classElement);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
       }
       return result;
@@ skipping 21 matching lines @@
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(
         operatorEqfunction.getEnclosingClass());
   }
 
   void initializeHelperClasses() {
     getInterceptorMethod =
         compiler.findInterceptor(const SourceString('getInterceptor'));
     interceptedNames =
         compiler.findInterceptor(const SourceString('interceptedNames'));
+    mapTypeToInterceptor =
+        compiler.findInterceptor(const SourceString('mapTypeToInterceptor'));
     dispatchPropertyName =
         compiler.findInterceptor(const SourceString('dispatchPropertyName'));
     getDispatchPropertyMethod =
         compiler.findInterceptor(const SourceString('getDispatchProperty'));
     setDispatchPropertyMethod =
         compiler.findInterceptor(const SourceString('setDispatchProperty'));
     getNativeInterceptorMethod =
         compiler.findInterceptor(const SourceString('getNativeInterceptor'));
     initializeDispatchPropertyMethod =
         compiler.findInterceptor(
@@ skipping 120 matching lines @@
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == compiler.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
         if (classElement == jsInterceptorClass) return;
-        if (!classElement.isNative()) {
+        if (classElement.isMixinApplication) {
           MixinApplicationElement mixinApplication = classElement;
           assert(member.getEnclosingClass() == mixinApplication.mixin);
           classesMixedIntoNativeClasses.add(mixinApplication.mixin);
         }
       },
       includeSuperAndInjectedMembers: true);
     }
   }
 
   void addInterceptors(ClassElement cls,
@@ skipping 88 matching lines @@
     } else if (cls == compiler.nullClass || cls == jsNullClass) {
       addInterceptors(jsNullClass, enqueuer, elements);
     } else if (cls == compiler.numClass || cls == jsNumberClass) {
       addInterceptors(jsIntClass, enqueuer, elements);
       addInterceptors(jsDoubleClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls == jsPlainJavaScriptObjectClass) {
       addInterceptors(jsPlainJavaScriptObjectClass, enqueuer, elements);
     } else if (cls == jsUnknownJavaScriptObjectClass) {
       addInterceptors(jsUnknownJavaScriptObjectClass, enqueuer, elements);
-    } else if (cls.isNative()) {
+    } else if (Elements.isNativeOrExtendsNative(cls)) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
     }
   }
 
   void registerUseInterceptor(Enqueuer enqueuer) {
     assert(!enqueuer.isResolutionQueue);
     if (!enqueuer.nativeEnqueuer.hasInstantiatedNativeClasses()) return;
     enqueuer.registerStaticUse(getNativeInterceptorMethod);
     enqueuer.registerStaticUse(defineNativeMethodsFinishMethod);
     enqueuer.registerStaticUse(initializeDispatchPropertyMethod);
@@ skipping 800 matching lines @@
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }