Don't hide interceptors in mirrors.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 398 matching lines @@
         var finishedClasses = {};
         init.interceptorsByTag = Object.create(null);
         init.leafTags = {};
 
         #;  // buildFinishClass(),
 
         #;  // buildTrivialNsmHandlers()
 
         for (var cls in pendingClasses) finishClass(cls);
       }''', [
-          DEBUG_FAST_OBJECTS, 
+          DEBUG_FAST_OBJECTS,
           backend.hasRetainedMetadata,
           needsMixinSupport,
           backend.isTreeShakingDisabled,
           buildFinishClass(),
           nsmEmitter.buildTrivialNsmHandlers()]);
- 
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {
     return condition ? node : new jsAst.EmptyStatement();
   }
 
   jsAst.FunctionDeclaration buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
     return js.statement('''
@@ skipping 173 matching lines @@
     return [
       js('$finishIsolateConstructorName = #', finishIsolateConstructorFunction)
     ];
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
     buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
+  /// In minified mode we want to keep the name for the most common core types.
+  bool _isNativeTypeNeedingReflectionName(Element element) {
+    if (!element.isClass()) return false;
+    return (element == compiler.intClass ||
+            element == compiler.doubleClass ||
+            element == compiler.numClass ||
+            element == compiler.stringClass ||
+            element == compiler.boolClass ||
+            element == compiler.nullClass ||
+            element == compiler.listClass);
+  }
+
   /// 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) {
     String name = elementOrSelector.name;
-    if (!backend.shouldRetainName(name)) {
-      if (name == '' && elementOrSelector is Element) {
-        // Make sure to retain names of unnamed constructors.
-        if (!backend.isNeededForReflection(elementOrSelector)) return null;
-      } else {
-        return null;
-      }
+    if (backend.shouldRetainName(name) ||
+        elementOrSelector is Element &&
+        // Make sure to retain names of unnamed constructors, and
+        // for common native types.
+        (name == '' && backend.isNeededForReflection(elementOrSelector) ||
+         _isNativeTypeNeedingReflectionName(elementOrSelector))) {
+
+      // TODO(ahe): Enable the next line when I can tell the difference between
+      // an instance method and a global.  They may have the same mangled name.
+      // if (recordedMangledNames.contains(mangledName)) return null;
+      recordedMangledNames.add(mangledName);
+      return getReflectionNameInternal(elementOrSelector, mangledName);
     }
-    // TODO(ahe): Enable the next line when I can tell the difference between
-    // an instance method and a global.  They may have the same mangled name.
-    // if (recordedMangledNames.contains(mangledName)) return null;
-    recordedMangledNames.add(mangledName);
-    return getReflectionNameInternal(elementOrSelector, mangledName);
+    return null;
   }
 
   String getReflectionNameInternal(elementOrSelector, String mangledName) {
     String name = elementOrSelector.name;
     if (elementOrSelector.isGetter()) return name;
     if (elementOrSelector.isSetter()) {
       if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
       String base = mangledName.substring(namer.setterPrefix.length);
       String getter = '${namer.getterPrefix}$base';
       mangledFieldNames[getter] = name;
@@ skipping 481 matching lines @@
     // neededClasses must only contain classes that have been resolved and
     // codegen'd. The rtiNeededClasses may contain additional classes, but
     // these are thought to not have been instantiated, so we neeed to be able
     // to identify them later and make sure we only emit "empty shells" without
     // fields, etc.
     typeTestEmitter.computeRtiNeededClasses();
     typeTestEmitter.rtiNeededClasses.removeAll(neededClasses);
     // rtiNeededClasses now contains only the "empty shells".
     neededClasses.addAll(typeTestEmitter.rtiNeededClasses);
 
+    // TODO(18175, floitsch): remove once issue 18175 is fixed.
+    if (neededClasses.contains(backend.jsIntClass)) {
+      neededClasses.add(compiler.intClass);
+    }
+    if (neededClasses.contains(backend.jsDoubleClass)) {
+      neededClasses.add(compiler.doubleClass);
+    }
+    if (neededClasses.contains(backend.jsNumberClass)) {
+      neededClasses.add(compiler.numClass);
+    }
+    if (neededClasses.contains(backend.jsStringClass)) {
+      neededClasses.add(compiler.stringClass);
+    }
+    if (neededClasses.contains(backend.jsBoolClass)) {
+      neededClasses.add(compiler.boolClass);
+    }
+    if (neededClasses.contains(backend.jsArrayClass)) {
+      neededClasses.add(compiler.listClass);
+    }
+
     // 5. Finally, sort the classes.
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     for (ClassElement element in sortedClasses) {
       if (typeTestEmitter.rtiNeededClasses.contains(element)) {
         // TODO(sigurdm): We might be able to defer some of these.
         outputClassLists.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
             () => new List<ClassElement>()).add(element);
       } else if (Elements.isNativeOrExtendsNative(element)) {
         // For now, native classes and related classes cannot be deferred.
@@ skipping 551 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }