Support for extending native classes

sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.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 NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 75 matching lines @@
         const SourceString('defineNativeMethods'));
     return backend.namer.isolateAccess(element);
   }
 
   String get defineNativeMethodsNonleafName {
     Element element = compiler.findHelper(
         const SourceString('defineNativeMethodsNonleaf'));
     return backend.namer.isolateAccess(element);
   }
 
+  String get defineNativeMethodsExtendedName {
+    Element element = compiler.findHelper(
+        const SourceString('defineNativeMethodsExtended'));
+    return backend.namer.isolateAccess(element);
+  }
+
   String get defineNativeMethodsFinishName {
     Element element = compiler.findHelper(
         const SourceString('defineNativeMethodsFinish'));
     return backend.namer.isolateAccess(element);
   }
 
   List<String> nativeTagsOfClass(ClassElement cls) {
     String quotedName = cls.nativeTagInfo.slowToString();
     return quotedName.substring(1, quotedName.length - 1).split(',');
   }
 
   /**
    * Writes the class definitions for the interceptors to [mainBuffer].
    * Writes code to associate dispatch tags with interceptors to [nativeBuffer].
    *
    * The interceptors are filtered to avoid emitting trivial interceptors.  For
    * example, if the program contains no code that can distinguish between the
    * numerous subclasses of `Element` then we can pretend that `Element` is a
    * leaf class, and all instances of subclasses of `Element` are instances of
    * `Element`.
    *
    * There is also a performance benefit (in addition to the obvious code size
    * benefit), due to how [getNativeInterceptor] works.  Finding the interceptor
    * of a leaf class in the hierarchy is more efficient that a non-leaf, so it
    * improves performance when more classes can be treated as leaves.
+   *
+   * [classes] contains native classes, mixin applications, and user subclasses
+   * of native classes.  ONLY the native classes are generated here.  [classes]
+   * is sorted in desired output order.
    */
   void generateNativeClasses(List<ClassElement> classes,
                              CodeBuffer mainBuffer) {
     // Compute a pre-order traversal of the subclass forest.  We actually want a
     // post-order traversal but it is easier to compute the pre-order and use it
     // in reverse.
 
     List<ClassElement> preOrder = <ClassElement>[];
     Set<ClassElement> seen = new Set<ClassElement>();
+    seen..add(compiler.objectClass)
+        ..add(backend.jsInterceptorClass);
     void walk(ClassElement element) {
-      if (seen.contains(element) || element == compiler.objectClass) return;
+      if (seen.contains(element)) return;
       seen.add(element);
       walk(element.superclass);
       preOrder.add(element);
     }
     classes.forEach(walk);
 
     // Generate code for each native class into [ClassBuilder]s.
 
     Map<ClassElement, ClassBuilder> builders =
         new Map<ClassElement, ClassBuilder>();
     for (ClassElement classElement in classes) {
-      ClassBuilder builder = generateNativeClass(classElement);
-      builders[classElement] = builder;
+      if (classElement.isNative()) {
+        ClassBuilder builder = generateNativeClass(classElement);
+        builders[classElement] = builder;
+      }
     }
 
     // Find which classes are needed and which are non-leaf classes.  Any class
     // that is not needed can be treated as a leaf class equivalent to some
     // needed class.
 
     Set<ClassElement> neededClasses = new Set<ClassElement>();
     Set<ClassElement> nonleafClasses = new Set<ClassElement>();
+
+    Map<ClassElement, List<ClassElement>> extensionPoints =
+        computeExtensionPoints(preOrder);
+
     neededClasses.add(compiler.objectClass);
 
     Set<ClassElement> neededByConstant =
         emitter.interceptorsReferencedFromConstants();
     Set<ClassElement> modifiedClasses =
         emitter.classesModifiedByEmitRuntimeTypeSupport();
 
     for (ClassElement classElement in preOrder.reversed) {
       // Post-order traversal ensures we visit the subclasses before their
       // superclass.  This makes it easy to tell if a class is needed because a
       // subclass is needed.
       ClassBuilder builder = builders[classElement];
       bool needed = false;
       if (builder == null) {
         // Mixin applications (native+mixin) are non-native, so [classElement]
         // has already been emitted as a regular class.  Mark [classElement] as
         // 'needed' to ensure the native superclass is needed.
         needed = true;
       } else if (!builder.isTrivial) {
         needed = true;
       } else if (neededByConstant.contains(classElement)) {
         needed = true;
       } else if (modifiedClasses.contains(classElement)) {
         // TODO(9556): Remove this test when [emitRuntimeTypeSupport] no longer
         // adds information to a class prototype or constructor.
         needed = true;
+      } else if (extensionPoints.containsKey(classElement)) {
+        needed = true;
       }
 
       if (needed || neededClasses.contains(classElement)) {
         neededClasses.add(classElement);
         neededClasses.add(classElement.superclass);
         nonleafClasses.add(classElement.superclass);
       }
     }
 
-    // Collect all the tags that map to each class.
+    // Collect all the tags that map to each native class.
 
     Map<ClassElement, Set<String>> leafTags =
         new Map<ClassElement, Set<String>>();
     Map<ClassElement, Set<String>> nonleafTags =
         new Map<ClassElement, Set<String>>();
 
     for (ClassElement classElement in classes) {
+      if (!classElement.isNative()) continue;
       List<String> nativeTags = nativeTagsOfClass(classElement);
 
-      if (nonleafClasses.contains(classElement)) {
+      if (nonleafClasses.contains(classElement) ||
+          extensionPoints.containsKey(classElement)) {
         nonleafTags
             .putIfAbsent(classElement, () => new Set<String>())
             .addAll(nativeTags);
       } else {
         ClassElement sufficingInterceptor = classElement;
         while (!neededClasses.contains(sufficingInterceptor)) {
           sufficingInterceptor = sufficingInterceptor.superclass;
         }
         if (sufficingInterceptor == compiler.objectClass) {
           sufficingInterceptor = backend.jsInterceptorClass;
         }
         leafTags
             .putIfAbsent(sufficingInterceptor, () => new Set<String>())
             .addAll(nativeTags);
       }
     }
 
     // Emit code to set up dispatch data that maps tags to the interceptors, but
     // only if native classes are actually instantiated.
     if (compiler.enqueuer.codegen.nativeEnqueuer
         .hasInstantiatedNativeClasses()) {
       void generateDefines(ClassElement classElement) {
-        generateDefineNativeMethods(leafTags[classElement], classElement,
-            defineNativeMethodsName);
-        generateDefineNativeMethods(nonleafTags[classElement], classElement,
-            defineNativeMethodsNonleafName);
+        generateDefineNativeMethods(leafTags[classElement],
+            null,
+            classElement, defineNativeMethodsName);
+        List<ClassElement> extensions = extensionPoints[classElement];
+        if (extensions == null) {
+          generateDefineNativeMethods(nonleafTags[classElement],
+              null,
+              classElement, defineNativeMethodsNonleafName);
+        } else {
+          generateDefineNativeMethods(nonleafTags[classElement],
+              makeSubclassList(extensions),
+              classElement, defineNativeMethodsExtendedName);
+        }
       }
       generateDefines(backend.jsInterceptorClass);
       for (ClassElement classElement in classes) {
         generateDefines(classElement);
       }
     }
 
     // Emit the native class interceptors that were actually used.
     for (ClassElement classElement in classes) {
+      if (!classElement.isNative()) continue;
       if (neededClasses.contains(classElement)) {
         // Define interceptor class for [classElement].
         emitter.emitClassBuilderWithReflectionData(
             backend.namer.getName(classElement),
             classElement, builders[classElement],
             emitter.bufferForElement(classElement, mainBuffer));
         emitter.needsDefineClass = true;
       }
     }
   }
 
+  /**
+   * Computes the native classes that are extended (subclassed) by non-native
+   * classes and the set non-mative classes that extend them.  (A List is used
+   * instead of a Set for out stability).
+   */
+  Map<ClassElement, List<ClassElement>> computeExtensionPoints(
+      List<ClassElement> classes) {
+    ClassElement nativeSuperclassOf(ClassElement element) {
+      if (element == null) return null;
+      if (element.isNative()) return element;
+      return nativeSuperclassOf(element.superclass);
+    }
+
+    ClassElement nativeAncestorOf(ClassElement element) {
+      return nativeSuperclassOf(element.superclass);
+    }
+
+    Map<ClassElement, List<ClassElement>> map =
+        new Map<ClassElement, List<ClassElement>>();
+
+    for (ClassElement classElement in classes) {
+      if (classElement.isNative()) continue;
+      ClassElement nativeAncestor = nativeAncestorOf(classElement);
+      if (nativeAncestor != null) {
+        map
+          .putIfAbsent(nativeAncestor, () => <ClassElement>[])
+          .add(classElement);
+      }
+    }
+
+    return map;
+  }
+
   ClassBuilder generateNativeClass(ClassElement classElement) {
     assert(!classElement.hasBackendMembers);
     nativeClasses.add(classElement);
 
     ClassElement superclass = classElement.superclass;
     assert(superclass != null);
     // Fix superclass.  TODO(sra): make native classes inherit from Interceptor.
+    assert(superclass != compiler.objectClass);
     if (superclass == compiler.objectClass) {
       superclass = backend.jsInterceptorClass;
     }
 
     String superName = backend.namer.getName(superclass);
 
     ClassBuilder builder = new ClassBuilder();
     emitter.emitClassConstructor(classElement, builder);
     emitter.emitSuper(superName, builder);
     bool hasFields = emitter.emitFields(
         classElement, builder, superName, classIsNative: true);
     int propertyCount = builder.properties.length;
     emitter.emitClassGettersSetters(classElement, builder);
     emitter.emitInstanceMembers(classElement, builder);
     emitter.emitIsTests(classElement, builder);
 
     if (!hasFields &&
         builder.properties.length == propertyCount &&
         superclass is! MixinApplicationElement) {
       builder.isTrivial = true;
     }
 
     return builder;
   }
 
   void generateDefineNativeMethods(
-      Set<String> tags, ClassElement classElement, String definer) {
+      Set<String> tags, jsAst.Expression extraArgument,
+      ClassElement classElement, String definer) {
     if (tags == null) return;
     String tagsString = (tags.toList()..sort()).join('|');
-    jsAst.Expression definition =
-        js(definer)(
-            [js.string(tagsString),
-             js(backend.namer.isolateAccess(classElement))]);
+
+    List arguments = [
+        js.string(tagsString),
+        js(backend.namer.isolateAccess(classElement))];
+    if (extraArgument != null) {
+      arguments.add(extraArgument);
+    }
+    jsAst.Expression definition = js(definer)(arguments);
 
     nativeBuffer.add(jsAst.prettyPrint(definition, compiler));
     nativeBuffer.add('$N$n');
   }
 
+  jsAst.Expression makeSubclassList(List<ClassElement> classes) {
+    return new jsAst.ArrayInitializer.from(
+        classes.map((ClassElement classElement) =>
+            js(backend.namer.isolateAccess(classElement))));
+  }
 
   void finishGenerateNativeClasses() {
     // TODO(sra): Put specialized version of getNativeMethods on
     // `Object.prototype` to avoid checking in `getInterceptor` and
     // specializations.
 
     // jsAst.Expression call = js(defineNativeMethodsFinishName)([]);
     // nativeBuffer.add(jsAst.prettyPrint(call, compiler));
     // nativeBuffer.add('$N$n');
   }
@@ skipping 144 matching lines @@
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }