Make native implementation classes for classes that are used as targets in @MirrorsUsed available f…

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
   final Set<HInstruction> allocatedFixedLists = new Set<HInstruction>();
 }
@@ skipping 213 matching lines @@
   TypeMask get dynamicType => compiler.typesTask.dynamicType;
   TypeMask get nullType => compiler.typesTask.nullType;
   TypeMask get emptyType => const TypeMask.nonNullEmpty();
   TypeMask indexablePrimitiveType;
   TypeMask readableArrayType;
   TypeMask mutableArrayType;
   TypeMask fixedArrayType;
   TypeMask extendableArrayType;
   TypeMask nonNullType;
 
+  /// Maps special classes to their implementation (JSXxx) class.
+  Map<ClassElement, ClassElement> implementationClasses;
 
   Element getNativeInterceptorMethod;
   bool needToInitializeDispatchProperty = false;
 
   final Namer namer;
 
   /**
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
@@ skipping 327 matching lines @@
       jsBoolClass = compiler.findInterceptor('JSBool'),
       jsMutableArrayClass = compiler.findInterceptor('JSMutableArray'),
       jsFixedArrayClass = compiler.findInterceptor('JSFixedArray'),
       jsExtendableArrayClass = compiler.findInterceptor('JSExtendableArray'),
       jsPlainJavaScriptObjectClass =
           compiler.findInterceptor('PlainJavaScriptObject'),
       jsUnknownJavaScriptObjectClass =
           compiler.findInterceptor('UnknownJavaScriptObject'),
     ];
 
+    implementationClasses = <ClassElement, ClassElement>{};
+    implementationClasses[compiler.intClass] = jsIntClass;
+    implementationClasses[compiler.boolClass] = jsBoolClass;
+    implementationClasses[compiler.numClass] = jsNumberClass;
+    implementationClasses[compiler.doubleClass] = jsDoubleClass;
+    implementationClasses[compiler.stringClass] = jsStringClass;
+    implementationClasses[compiler.listClass] = jsArrayClass;
+
     jsIndexableClass = compiler.findInterceptor('JSIndexable');
     jsMutableIndexableClass = compiler.findInterceptor('JSMutableIndexable');
 
     // TODO(kasperl): Some tests do not define the special JSArray
     // subclasses, so we check to see if they are defined before
     // trying to resolve them.
     if (jsFixedArrayClass != null) {
       jsFixedArrayClass.ensureResolved(compiler);
     }
     if (jsExtendableArrayClass != null) {
@@ skipping 696 matching lines @@
           LibraryElement importedLibrary = library.getLibraryFromTag(tag);
           if (importedLibrary != compiler.mirrorsLibrary) continue;
           compiler.withCurrentElement(library, () {
             compiler.reportInfo(importTag, MessageKind.MIRROR_IMPORT);
           });
         }
       }
     }
   }
 
+  Element getDartClass(Element element) {
+    for (ClassElement dartClass in implementationClasses.keys) {
+      if (element == implementationClasses[dartClass]) {
+        return dartClass;
+      }
+    }
+    return element;
+  }
+
   Element getImplementationClass(Element element) {
-    if (element == compiler.intClass) {
-      return jsIntClass;
-    } else if (element == compiler.boolClass) {
-      return jsBoolClass;
-    } else if (element == compiler.numClass) {
-      return jsNumberClass;
-    } else if (element == compiler.doubleClass) {
-      return jsDoubleClass;
-    } else if (element == compiler.stringClass) {
-      return jsStringClass;
-    } else if (element == compiler.listClass) {
-      return jsArrayClass;
-    } else {
-      return element;
+    for (ClassElement dartClass in implementationClasses.keys) {
+      if (element == dartClass) {
+        return implementationClasses[dartClass];
+      }
     }
+    return element;
   }
 
   /**
    * Returns the checked mode helper that will be needed to do a type check/type
    * cast on [type] at runtime. Note that this method is being called both by
    * the resolver with interface types (int, String, ...), and by the SSA
    * backend with implementation types (JSInt, JSString, ...).
    */
   CheckedModeHelper getCheckedModeHelper(DartType type, {bool typeCast}) {
     return getCheckedModeHelperInternal(
@@ skipping 407 matching lines @@
     if (hasInsufficientMirrorsUsed) return true;
     return isNeededForReflection(element);
   }
 
   /**
    * Returns `true` if the emitter must emit the element even though there
    * is no direct use in the program, but because the reflective system may
    * need to access it.
    */
   bool isNeededForReflection(Element element) {
+    element = getDartClass(element);
     if (hasInsufficientMirrorsUsed) return isTreeShakingDisabled;
     /// Record the name of [element] in [symbolsUsed]. Return true for
     /// convenience.
     bool registerNameOf(Element element) {
       symbolsUsed.add(element.name);
       if (element.isConstructor()) {
         symbolsUsed.add(element.getEnclosingClass().name);
       }
       return true;
     }
@@ skipping 152 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }