Handle super-method call

pkg/compiler/lib/src/js_backend/backend_usage.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 '../common.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart' show Element;
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../util/util.dart' show Setlet;
@@ skipping 22 matching lines @@
 
   /// `true` of `Object.runtimeType` is used.
   bool get isRuntimeTypeUsed;
 
   /// `true` if the `dart:isolate` library is in use.
   bool get isIsolateInUse;
 
   /// `true` if `Function.apply` is used.
   bool get isFunctionApplyUsed;
 
+  /// `true` if 'dart:mirrors' features are used.
+  bool get isMirrorsUsed;
+
   /// `true` if `noSuchMethod` is used.
   bool get isNoSuchMethodUsed;
 }
 
 abstract class BackendUsageBuilder {
   /// The backend must *always* call this method when enqueuing an function
   /// element. Calls done by the backend are not seen by global
   /// optimizations, so they would make these optimizations unsound.
   /// Therefore we need to collect the list of methods the backend may
   /// call.
@@ skipping 55 matching lines @@
 
   /// `true` of `Object.runtimeType` is used.
   bool isRuntimeTypeUsed = false;
 
   /// `true` if the `dart:isolate` library is in use.
   bool isIsolateInUse = false;
 
   /// `true` if `Function.apply` is used.
   bool isFunctionApplyUsed = false;
 
+  /// `true` if 'dart:mirrors' features are used.
+  bool isMirrorsUsed = false;
+
   /// `true` if `noSuchMethod` is used.
   bool isNoSuchMethodUsed = false;
 
   BackendUsageBuilderImpl(this._commonElements);
 
   @override
   void registerBackendFunctionUse(FunctionEntity element) {
     assert(_isValidBackendUse(element),
         failedAt(element, "Backend use of $element is not allowed."));
     _helperFunctionsUsed.add(element);
@@ skipping 106 matching lines @@
 
   void registerUsedMember(MemberEntity member) {
     if (member == _commonElements.getIsolateAffinityTagMarker) {
       _needToInitializeIsolateAffinityTag = true;
     } else if (member == _commonElements.requiresPreambleMarker) {
       requiresPreamble = true;
     } else if (member == _commonElements.invokeOnMethod) {
       isInvokeOnUsed = true;
     } else if (_commonElements.isFunctionApplyMethod(member)) {
       isFunctionApplyUsed = true;
+    } else if (member.library == _commonElements.mirrorsLibrary) {
+      isMirrorsUsed = true;
     }
   }
 
   void registerGlobalFunctionDependency(FunctionEntity element) {
     assert(element != null);
     if (_globalFunctionDependencies == null) {
       _globalFunctionDependencies = new Setlet<FunctionEntity>();
     }
     _globalFunctionDependencies.add(element);
   }
@@ skipping 12 matching lines @@
         globalClassDependencies: _globalClassDependencies,
         helperFunctionsUsed: _helperFunctionsUsed,
         helperClassesUsed: _helperClassesUsed,
         needToInitializeIsolateAffinityTag: _needToInitializeIsolateAffinityTag,
         needToInitializeDispatchProperty: _needToInitializeDispatchProperty,
         requiresPreamble: requiresPreamble,
         isInvokeOnUsed: isInvokeOnUsed,
         isRuntimeTypeUsed: isRuntimeTypeUsed,
         isIsolateInUse: isIsolateInUse,
         isFunctionApplyUsed: isFunctionApplyUsed,
+        isMirrorsUsed: isMirrorsUsed,
         isNoSuchMethodUsed: isNoSuchMethodUsed);
   }
 }
 
 class BackendUsageImpl implements BackendUsage {
   // TODO(johnniwinther): Remove the need for these.
   final Set<FunctionEntity> _globalFunctionDependencies;
   final Set<ClassEntity> _globalClassDependencies;
 
   /// Set of functions called by the backend.
@@ skipping 13 matching lines @@
 
   /// `true` of `Object.runtimeType` is used.
   final bool isRuntimeTypeUsed;
 
   /// `true` if the `dart:isolate` library is in use.
   final bool isIsolateInUse;
 
   /// `true` if `Function.apply` is used.
   final bool isFunctionApplyUsed;
 
+  /// `true` if 'dart:mirrors' features are used.
+  final bool isMirrorsUsed;
+
   /// `true` if `noSuchMethod` is used.
   final bool isNoSuchMethodUsed;
 
   BackendUsageImpl(
       {Set<FunctionEntity> globalFunctionDependencies,
       Set<ClassEntity> globalClassDependencies,
       Set<FunctionEntity> helperFunctionsUsed,
       Set<ClassEntity> helperClassesUsed,
       this.needToInitializeIsolateAffinityTag,
       this.needToInitializeDispatchProperty,
       this.requiresPreamble,
       this.isInvokeOnUsed,
       this.isRuntimeTypeUsed,
       this.isIsolateInUse,
       this.isFunctionApplyUsed,
+      this.isMirrorsUsed,
       this.isNoSuchMethodUsed})
       : this._globalFunctionDependencies = globalFunctionDependencies,
         this._globalClassDependencies = globalClassDependencies,
         this._helperFunctionsUsed = helperFunctionsUsed,
         this._helperClassesUsed = helperClassesUsed;
 
   @override
   bool isFunctionUsedByBackend(FunctionEntity element) {
     return _helperFunctionsUsed.contains(element);
   }
 
   @override
   bool isFieldUsedByBackend(FieldEntity element) {
     return _helperClassesUsed.contains(element.enclosingClass);
   }
 
   @override
   Iterable<FunctionEntity> get globalFunctionDependencies =>
       _globalFunctionDependencies ?? const <FunctionEntity>[];
 
   @override
   Iterable<ClassEntity> get globalClassDependencies =>
       _globalClassDependencies ?? const <ClassEntity>[];
 
   Iterable<FunctionEntity> get helperFunctionsUsed => _helperFunctionsUsed;
 
   Iterable<ClassEntity> get helperClassesUsed => _helperClassesUsed;
 }