It's alive!

pkg/compiler/lib/src/js_backend/mirrors_data.dart

 // Copyright (c) 2017, 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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
@@ skipping 375 matching lines @@
   }
 
   bool isAccessibleByReflection(Element element) {
     if (element.isLibrary) {
       return false;
     } else if (element.isClass) {
       return isClassAccessibleByReflection(element);
     } else if (element.isTypedef) {
       return isTypedefAccessibleByReflection(element);
     } else {
-      return isMemberAccessibleByReflection(element);
+      MemberElement member = element;
+      return isMemberAccessibleByReflection(member);
     }
   }
 
   ClassElement _getDartClass(ClassElement cls) {
     if (cls == _commonElements.jsIntClass) {
       return _commonElements.intClass;
     } else if (cls == _commonElements.jsBoolClass) {
       return _commonElements.boolClass;
     } else if (cls == _commonElements.jsNumberClass) {
       return _commonElements.numClass;
     } else if (cls == _commonElements.jsDoubleClass) {
       return _commonElements.doubleClass;
     } else if (cls == _commonElements.jsStringClass) {
       return _commonElements.stringClass;
     } else if (cls == _commonElements.jsArrayClass) {
       return _commonElements.listClass;
     } else if (cls == _commonElements.jsNullClass) {
       return _commonElements.nullClass;
     } else {
       return cls;
     }
   }
 
-  bool isMemberAccessibleByReflection(MemberElement element) {
+  bool isMemberAccessibleByReflection(MemberEntity element) {
     return _membersNeededForReflection.contains(element);
   }
 
   /// Returns true if this element has to be enqueued due to
   /// mirror usage. Might be a subset of [referencedFromMirrorSystem] if
   /// normal tree shaking is still active ([isTreeShakingDisabled] is false).
   bool requiredByMirrorSystem(Element element) {
     return hasInsufficientMirrorsUsed && isTreeShakingDisabled ||
         matchesMirrorsMetaTarget(element) ||
         classesInMirrorsUsedTargets.contains(element) ||
@@ skipping 75 matching lines @@
       ConstantValue value =
           _compiler.constants.getConstantValue(metadata.constant);
       if (value == null) continue;
       DartType type = value.getType(_commonElements);
       if (type is InterfaceType && metaTargetsUsed.contains(type.element))
         return true;
     }
     return false;
   }
 
+  void createImmutableSets() {
+    _classesNeededForReflection = const ImmutableEmptySet<ClassElement>();
+    _typedefsNeededForReflection = const ImmutableEmptySet<TypedefElement>();
+    _membersNeededForReflection = const ImmutableEmptySet<MemberElement>();
+    _closuresNeededForReflection =
+        const ImmutableEmptySet<LocalFunctionElement>();
+  }
+
   /**
    * Visits all classes and computes whether its members are needed for
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
    * reflection locally when looking at the member: We lack the information by
    * which classes a member is inherited. Called after resolution is complete.
    *
    * We filter out private libraries here, as their elements should not
    * be visible by reflection unless some other interfaces makes them
    * accessible.
    */
   void computeMembersNeededForReflection(
       ResolutionWorldBuilder worldBuilder, ClosedWorld closedWorld) {
     if (_membersNeededForReflection != null) return;
     if (closedWorld.commonElements.mirrorsLibrary == null) {
-      _classesNeededForReflection = const ImmutableEmptySet<ClassElement>();
-      _typedefsNeededForReflection = const ImmutableEmptySet<TypedefElement>();
-      _membersNeededForReflection = const ImmutableEmptySet<MemberElement>();
-      _closuresNeededForReflection =
-          const ImmutableEmptySet<LocalFunctionElement>();
+      createImmutableSets();
       return;
     }
     _classesNeededForReflection = new Set<ClassElement>();
     _typedefsNeededForReflection = new Set<TypedefElement>();
     _membersNeededForReflection = new Set<MemberElement>();
     _closuresNeededForReflection = new Set<LocalFunctionElement>();
 
     // Compute a mapping from class to the closures it contains, so we
     // can include the correct ones when including the class.
     Map<ClassElement, List<LocalFunctionElement>> closureMap =
@@ skipping 143 matching lines @@
   }
 
   /// Called when `const Symbol(name)` is seen.
   void registerConstSymbol(String name) {
     symbolsUsed.add(name);
     if (name.endsWith('=')) {
       symbolsUsed.add(name.substring(0, name.length - 1));
     }
   }
 }