Support for extending native classes

sdk/lib/_internal/compiler/implementation/js_backend/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;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 2613 matching lines @@
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
+      // `mapTypeToInterceptor` is handled in [emitMapTypeToInterceptor].
+      if (element == backend.mapTypeToInterceptor) continue;
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
           js('$isolateProperties.${namer.getName(element)} = #',
               constantEmitter.referenceInInitializationContext(initialValue));
         buffer.write(jsAst.prettyPrint(init, compiler));
         buffer.write('$N');
       });
     }
   }
@@ skipping 405 matching lines @@
     }
 
     bool hasArray = false;
     bool hasBool = false;
     bool hasDouble = false;
     bool hasInt = false;
     bool hasNull = false;
     bool hasNumber = false;
     bool hasString = false;
     bool hasNative = false;
+    bool anyNativeClasses = compiler.enqueuer.codegen.nativeEnqueuer
+          .hasInstantiatedNativeClasses();
+
     for (ClassElement cls in classes) {
       if (cls == backend.jsArrayClass ||
           cls == backend.jsMutableArrayClass ||
           cls == backend.jsFixedArrayClass ||
           cls == backend.jsExtendableArrayClass) hasArray = true;
       else if (cls == backend.jsBoolClass) hasBool = true;
       else if (cls == backend.jsDoubleClass) hasDouble = true;
       else if (cls == backend.jsIntClass) hasInt = true;
       else if (cls == backend.jsNullClass) hasNull = true;
       else if (cls == backend.jsNumberClass) hasNumber = true;
       else if (cls == backend.jsStringClass) hasString = true;
       else {
-        // TODO(sra): The set of classes includes classes mixed-in to
-        // interceptor classes.
-        // assert(cls == compiler.objectClass || cls.isNative());
-        if (cls.isNative()) hasNative = true;
+        // The set of classes includes classes mixed-in to interceptor classes
+        // and user extensions of native classes.
+        //
+        // The set of classes also includes the 'primitive' interceptor
+        // PlainJavaScriptObject even when it has not been resolved, since it is
+        // only resolved through the reference in getNativeInterceptor when
+        // getNativeInterceptor is marked as used.  Guard against probing
+        // unresolved PlainJavaScriptObject by testing for anyNativeClasses.
+
+        if (anyNativeClasses) {
+          if (Elements.isNativeOrExtendsNative(cls)) hasNative = true;
+        }
       }
     }
     if (hasDouble) {
       hasNumber = true;
     }
     if (hasInt) hasNumber = true;
 
     if (classes == backend.interceptedClasses) {
       // I.e. this is the general interceptor.
-      hasNative = compiler.enqueuer.codegen.nativeEnqueuer
-          .hasInstantiatedNativeClasses();
+      hasNative = anyNativeClasses;
     }
 
     jsAst.Block block = new jsAst.Block.empty();
 
     if (hasNumber) {
       jsAst.Statement whenNumber;
 
       /// Note: there are two number classes in play: Dart's [num],
       /// and JavaScript's Number (typeof receiver == 'number').  This
       /// is the fallback used when we have determined that receiver
@@ skipping 142 matching lines @@
     rtiNeededClasses.removeAll(neededClasses);
     // rtiNeededClasses now contains only the "empty shells".
     neededClasses.addAll(rtiNeededClasses);
 
     // 5. Finally, sort the classes.
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     for (ClassElement element in sortedClasses) {
       if (rtiNeededClasses.contains(element)) {
         regularClasses.add(element);
-      } else if (element.isNative()) {
-        // For now, native classes cannot be deferred.
+      } else if (Elements.isNativeOrExtendsNative(element)) {
+        // For now, native classes and related classes cannot be deferred.
         nativeClasses.add(element);
+        if (!element.isNative()) {
+          assert(invariant(element, !isDeferred(element)));
+          regularClasses.add(element);
+        }
       } else if (isDeferred(element)) {
         deferredClasses.add(element);
       } else {
         regularClasses.add(element);
       }
     }
   }
 
   Set<ClassElement> computeRtiNeededClasses() {
     void addClassWithSuperclasses(ClassElement cls) {
@@ skipping 243 matching lines @@
       }).toList();
     jsAst.ArrayInitializer array =
         new jsAst.ArrayInitializer(invocationNames.length, elements);
 
     jsAst.Expression assignment = js('$isolateProperties.$name = #', array);
 
     buffer.write(jsAst.prettyPrint(assignment, compiler));
     buffer.write(N);
   }
 
+  /**
+   * Emit initializer for [mapTypeToInterceptor] data structure used by
+   * [findInterceptorForType].  See declaration of [mapTypeToInterceptor] in
+   * `interceptors.dart`.
+   */
+  void emitMapTypeToInterceptor(CodeBuffer buffer) {
+    // TODO(sra): Perhaps inject a constant instead?
+    // TODO(sra): Filter by subclasses of native types.
+    List<jsAst.Expression> elements = <jsAst.Expression>[];
+    ConstantHandler handler = compiler.constantHandler;
+    List<Constant> constants = handler.getConstantsForEmission();
+    for (Constant constant in constants) {
+      if (constant is TypeConstant) {
+        TypeConstant typeConstant = constant;
+        Element element = typeConstant.representedType.element;
+        if (element is ClassElement) {
+          ClassElement classElement = element;
+          elements.add(backend.emitter.constantReference(constant));
+          elements.add(js(namer.isolateAccess(classElement)));
+        }
+      }
+    }
+
+    jsAst.ArrayInitializer array = new jsAst.ArrayInitializer.from(elements);
+    String name = backend.namer.getName(backend.mapTypeToInterceptor);
+    jsAst.Expression assignment = js('$isolateProperties.$name = #', array);
+
+    buffer.write(jsAst.prettyPrint(assignment, compiler));
+    buffer.write(N);
+  }
+
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.Fun fun = js.fun([], [
       js('$isolateProperties = {}'),
     ]
     ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
@@ skipping 312 matching lines @@
       emitGetInterceptorMethods(mainBuffer);
       // Constants in checked mode call into RTI code to set type information
       // which may need getInterceptor methods, so we have to make sure that
       // [emitGetInterceptorMethods] has been called.
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitOneShotInterceptors(mainBuffer);
       emitInterceptedNames(mainBuffer);
+      emitMapTypeToInterceptor(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       mainBuffer.add(nativeBuffer);
 
       emitMetadata(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('${namer.CURRENT_ISOLATE}$_=${_}null$N');
@@ skipping 237 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;