Fix runtimeType.toString for tear-offs.

pkg/compiler/lib/src/js_emitter/new_emitter/model_emitter.dart

 // Copyright (c) 2014, 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 dart2js.new_js_emitter.model_emitter;
 
 import '../../constants/values.dart' show ConstantValue, FunctionConstantValue;
 import '../../dart2jslib.dart' show Compiler;
 import '../../elements/elements.dart' show ClassElement, FunctionElement;
 import '../../js/js.dart' as js;
@@ skipping 70 matching lines @@
   final NativeEmitter nativeEmitter;
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// For deferred loading we communicate the initializers via this global var.
   static const String deferredInitializersGlobal =
       r"$__dart_deferred_initializers__";
 
   static const String deferredExtension = "part.js";
 
-  static const String typeNameProperty = r"builtin$cls";
-
   ModelEmitter(Compiler compiler, Namer namer, this.nativeEmitter)
       : this.compiler = compiler,
         this.namer = namer {
 
     this.constantEmitter = new ConstantEmitter(
         compiler, namer, this.generateConstantReference,
         constantListGenerator);
   }
 
   js.Expression constantListGenerator(js.Expression array) {
@@ skipping 368 matching lines @@
   }
 
   static final String readMetadataTypeName = "readMetadataType";
 
   js.Statement get readMetadataTypeFunction {
     // Types are non-evaluated and must be compiled at first use.
     // Compiled strings are guaranteed not to be strings, and it's thus safe
     // to use a type-test to determine if a type has already been compiled.
     return js.js.statement('''function $readMetadataTypeName(index) {
       var type = #typesAccess[index];
-      if (typeof type == 'string') {
+      if (typeof type == "string") {
         type = expressionCompile(type);
         #typesAccess[index] = type;
       }
       return type;
     }''', {"typesAccess": generateEmbeddedGlobalAccess(TYPES)});
   }
 
   js.Template get templateForReadType {
     // TODO(floitsch): make sure that no local variable shadows the access to
     // the readMetadataType function.
     return js.js.expressionTemplateFor('$readMetadataTypeName(#)');
   }
 
   static final String readMetadataName = "readLazyMetadata";
   static final String lazyMetadataName = "lazy_$METADATA";
 
   js.Statement get readMetadataFunction {
     // Types are non-evaluated and must be compiled at first use.
     // Compiled strings are guaranteed not to be strings, and it's thus safe
     // to use a type-test to determine if a type has already been compiled.
     return js.js.statement('''function $readMetadataName(index) {
       var lazyMetadata = #lazyMetadataAccess[index];
-      if (typeof lazyMetadata == 'string') {
+      if (typeof lazyMetadata == "string") {
         #metadataAccess[index] = expressionCompile(lazyMetadata);
         #lazyMetadataAccess[index] = null;
       }
       return #metadataAccess[index];
     }''', {
       "lazyMetadataAccess": generateEmbeddedGlobalAccess(lazyMetadataName),
       "metadataAccess": generateEmbeddedGlobalAccess(METADATA)
     });
   }
 
@@ skipping 496 matching lines @@
     // We assume that all constants are in the same holder.
     var holder = holders[constants[0]];
     for (var i = 1; i < constants.length; i += 2) {
       var name = constants[i];
       var initializer = constants[i + 1];
       setupConstant(name, holder, initializer);
     }
   }
 
   function setupStatic(name, holder, descriptor, typesOffset) {
-    if (typeof descriptor == 'string') {
+    if (typeof descriptor == "string") {
       holder[name] = function() {
         if (descriptor == null) {
           // Already compiled. This happens when we have calls to the static as
           // arguments to the static: `foo(foo(499))`;
           return holder[name].apply(this, arguments);
         }
         var method = compile(name, descriptor);
         holder[name] = method;
         descriptor = null;  // GC the descriptor.
         return method.apply(this, arguments);
@@ skipping 146 matching lines @@
     } else {
       constructor = descriptor[2];
       functionsIndex = 3;
     }
 
     for (var i = functionsIndex; i < descriptor.length; i += 2) {
       parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1],
                               typesOffset);
     }
 
-    constructor.$typeNameProperty = name;  // Needed for RTI.
+    if (typeof constructor.name != "string") {
+      // IE does not store the name, but allows to modify the property.
+      constructor.name = name;
+    }
     constructor.prototype = prototype;
     prototype[#operatorIsPrefix + name] = constructor;
     prototype.constructor = constructor;
     return constructor;
   }
 
   function fillPrototypeWithMixedIn(mixinName, mixinHolderIndex, prototype) {
     var mixin = holders[mixinHolderIndex][mixinName].ensureResolved();
     var mixinPrototype = mixin.prototype;
 
@@ skipping 77 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 })(Date.now(), #code)
 }""";
 
 }