Implement ClassMirror.superinterfaces.

dart/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 1278 matching lines @@
   }
 
   /// Returns the "reflection name" of an [Element] or [Selector].
   /// The reflection name of a getter 'foo' is 'foo'.
   /// The reflection name of a setter 'foo' is 'foo='.
   /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
   /// number of required arguments, M is the number of optional arguments, and
   /// O is the named arguments.
   /// The reflection name of a constructor is similar to a regular method but
   /// starts with 'new '.
+  /// The reflection name of class 'C' is 'C'.
+  /// An anonymous mixin application has no reflection name.
   /// This is used by js_mirrors.dart.
   String getReflectionName(elementOrSelector, String mangledName) {
     SourceString name = elementOrSelector.name;
     if (!backend.shouldRetainName(name)) {
       if (name == const SourceString('') && elementOrSelector is Element) {
         // Make sure to retain names of unnamed constructors.
         if (!backend.isNeededForReflection(elementOrSelector)) return null;
       } else {
         return null;
       }
@@ skipping 666 matching lines @@
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     if (!buffer.isEmpty) {
       buffer.write(',$n$n');
     }
     buffer.write('$className:$_');
     buffer.write(jsAst.prettyPrint(builder.toObjectInitializer(), compiler));
     if (backend.shouldRetainName(classElement.name)) {
       String reflectionName = getReflectionName(classElement, className);
-      buffer.write(',$n$n"+$reflectionName": 0');
+      List<int> interfaces = <int>[];
+      for (DartType interface in classElement.interfaces) {
+        interfaces.add(reifyType(interface));
+      }
+      buffer.write(',$n$n"+$reflectionName": $interfaces');
     }
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
   int _selectorRank(Selector selector) {
@@ skipping 2010 matching lines @@
     compiler.reportMessage(compiler.spanFromSpannable(element),
                            MessageKind.GENERIC.error({'text': message}),
                            api.Diagnostic.WARNING);
   }
 
   // TODO(ahe): This code should be integrated in finishClasses.
   String getReflectionDataParser() {
     String metadataField = '"${namer.metadataField}"';
     return '''
 (function (reflectionData) {
+'''
+// [map] returns an object literal that V8 shouldn't try to optimize with a
+// hidden class. This prevents a potential performance problem where V8 tries
+// to build a hidden class for an object used as a hashMap.
+'''
+  function map(x){x={x:x};delete x.x;return x}
   if (!init.libraries) init.libraries = [];
-  if (!init.mangledNames) init.mangledNames = {};
-  if (!init.mangledGlobalNames) init.mangledGlobalNames = {};
-  if (!init.statics) init.statics = {};
+  if (!init.mangledNames) init.mangledNames = map();
+  if (!init.mangledGlobalNames) init.mangledGlobalNames = map();
+  if (!init.statics) init.statics = map();
+  if (!init.interfaces) init.interfaces = map();
   var libraries = init.libraries;
   var mangledNames = init.mangledNames;
   var mangledGlobalNames = init.mangledGlobalNames;
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   var length = reflectionData.length;
   for (var i = 0; i < length; i++) {
     var data = reflectionData[i];
 '''
 // [data] contains these elements:
 // 0. The library name (not unique).
@@ skipping 15 matching lines @@
     var functions = [];
     function processStatics(descriptor) {
       for (var property in descriptor) {
         if (!hasOwnProperty.call(descriptor, property)) continue;
         if (property === "") continue;
         var element = descriptor[property];
         var firstChar = property.substring(0, 1);
         var previousProperty;
         if (firstChar === "+") {
           mangledGlobalNames[previousProperty] = property.substring(1);
+          if (element && element.length) '''

[ngeoffray, 2013/08/15 06:52:33]

This ''' quote here is confusing. My guess is that I won't be the only one
wondering what is going on, so maybe find a way to explain, or change it.

[ahe, 2013/08/15 09:58:24]

Done.

+'''init.interfaces[previousProperty] = element;
         } else if (firstChar === "@") {
           property = property.substring(1);
           ${namer.CURRENT_ISOLATE}[property][$metadataField] = element;
         } else if (typeof element === "function") {
           ${namer.CURRENT_ISOLATE}[previousProperty = property] = element;
           functions.push(property);
         } else {
           previousProperty = property;
           var newDesc = {};
           var previousProp;
@@ skipping 28 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].
 """;