Split MirrorsData

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';
 import '../elements/resolution_types.dart';
 import '../options.dart';
 import '../world.dart';
 import '../universe/world_builder.dart';
 import '../util/emptyset.dart';
 import 'backend_helpers.dart';
 import 'constant_handler_javascript.dart';
 
-class MirrorsData {
+abstract class MirrorsData {
+  /// True if a call to preserveMetadataMarker has been seen.  This means that
+  /// metadata must be retained for dart:mirrors to work correctly.
+  // resolution-empty-queue
+  bool get mustRetainMetadata;
+
+  /// True if any metadata has been retained.  This is slightly different from
+  /// [mustRetainMetadata] and tells us if any metadata was retained.  For
+  /// example, if [mustRetainMetadata] is true but there is no metadata in the
+  /// program, this variable will stil be false.
+  // emitter
+  bool get hasRetainedMetadata;
+
+  /// True if a call to preserveLibraryNames has been seen.
+  // emitter
+  bool get mustRetainLibraryNames;
+
+  /// True if a call to preserveNames has been seen.
+  // resolution-empty-queue
+  bool get mustPreserveNames;
+
+  /// True if a call to disableTreeShaking has been seen.
+  bool get isTreeShakingDisabled;
+
+  /// True if a call to preserveUris has been seen and the preserve-uris flag
+  /// is set.
+  bool get mustPreserveUris;
+
+  /// Set of symbols that the user has requested for reflection.
+  Iterable<String> get symbolsUsed;
+
+  /// Set of elements that the user has requested for reflection.
+  Iterable<Element> get targetsUsed;
+
+  /// Should [element] (a getter) that would normally not be generated due to
+  /// treeshaking be retained for reflection?
+  bool shouldRetainGetter(Element element);
+
+  /// Should [element] (a setter) hat would normally not be generated due to
+  /// treeshaking be retained for reflection?
+  bool shouldRetainSetter(Element element);
+
+  /// Should [name] be retained for reflection?
+  bool shouldRetainName(String name);
+
+  /// Returns true if this element is covered by a mirrorsUsed annotation.
+  ///
+  /// Note that it might still be ok to tree shake the element away if no
+  /// reflection is used in the program (and thus [isTreeShakingDisabled] is
+  /// still false). Therefore _do not_ use this predicate to decide inclusion
+  /// in the tree, use [requiredByMirrorSystem] instead.
+  bool referencedFromMirrorSystem(Element element, [recursive = true]);
+
+  /// Returns `true` if [element] can be accessed through reflection, that is,
+  /// is in the set of elements covered by a `MirrorsUsed` annotation.
+  ///
+  /// This property is used to tag emitted elements with a marker which is
+  /// checked by the runtime system to throw an exception if an element is
+  /// accessed (invoked, get, set) that is not accessible for the reflective
+  /// system.
+  bool isAccessibleByReflection(Element element);
+
+  bool retainMetadataOf(Element element);
+
+  bool invokedReflectively(Element element);
+
+  /// Returns `true` if this member element needs reflection information at
+  /// runtime.
+  bool isMemberAccessibleByReflection(MemberElement 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);
+}
+
+abstract class MirrorsDataBuilder {
+  void registerUsedMember(MemberElement member);
+
+  /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
+  /// annotations. The arguments corresponds to the unions of the corresponding
+  /// fields of the annotations.
+  void registerMirrorUsage(
+      Set<String> symbols, Set<Element> targets, Set<Element> metaTargets);
+
+  /// Called when `const Symbol(name)` is seen.
+  void registerConstSymbol(String name);
+
+  void maybeMarkClosureAsNeededForReflection(
+      ClosureClassElement globalizedElement,
+      FunctionElement callFunction,
+      FunctionElement function);
+
+  void computeMembersNeededForReflection(
+      ResolutionWorldBuilder worldBuilder, ClosedWorld closedWorld);
+}
+
+class MirrorsDataImpl implements MirrorsData, MirrorsDataBuilder {
   /// True if a call to preserveMetadataMarker has been seen.  This means that
   /// metadata must be retained for dart:mirrors to work correctly.
   bool mustRetainMetadata = false;
 
   /// True if any metadata has been retained.  This is slightly different from
   /// [mustRetainMetadata] and tells us if any metadata was retained.  For
   /// example, if [mustRetainMetadata] is true but there is no metadata in the
   /// program, this variable will stil be false.
   bool hasRetainedMetadata = false;
 
   /// True if a call to preserveLibraryNames has been seen.
   bool mustRetainLibraryNames = false;
 
   /// True if a call to preserveNames has been seen.
   bool mustPreserveNames = false;
 
   /// True if a call to disableTreeShaking has been seen.
   bool isTreeShakingDisabled = false;
 
   /// True if there isn't sufficient @MirrorsUsed data.
   bool hasInsufficientMirrorsUsed = false;
 
   /// True if a call to preserveUris has been seen and the preserve-uris flag
   /// is set.
   bool mustPreserveUris = false;
 
-  /// List of symbols that the user has requested for reflection.
+  /// Set of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
-  /// List of elements that the user has requested for reflection.
+  /// Set of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<Element> metaTargetsUsed = new Set<Element>();
 
   // TODO(johnniwinther): Avoid the need for this.
   final Compiler _compiler;
 
   final CompilerOptions _options;
 
   final CommonElements _commonElements;
 
   final BackendHelpers _helpers;
 
   final JavaScriptConstantCompiler _constants;
 
-  MirrorsData(this._compiler, this._options, this._commonElements,
+  MirrorsDataImpl(this._compiler, this._options, this._commonElements,
       this._helpers, this._constants);
 
   void registerUsedMember(MemberElement member) {
     if (member == _helpers.disableTreeShakingMarker) {
       isTreeShakingDisabled = true;
     } else if (member == _helpers.preserveNamesMarker) {
       mustPreserveNames = true;
     } else if (member == _helpers.preserveMetadataMarker) {
       mustRetainMetadata = true;
     } else if (member == _helpers.preserveUrisMarker) {
@@ skipping 79 matching lines @@
           targetsUsed.add(field.getter);
           targetsUsed.add(field.setter);
         } else {
           targetsUsed.add(target);
         }
       }
     }
     if (metaTargets != null) metaTargetsUsed.addAll(metaTargets);
   }
 
-  /**
-   * Returns `true` if [element] can be accessed through reflection, that is,
-   * is in the set of elements covered by a `MirrorsUsed` annotation.
-   *
-   * This property is used to tag emitted elements with a marker which is
-   * checked by the runtime system to throw an exception if an element is
-   * accessed (invoked, get, set) that is not accessible for the reflective
-   * system.
-   */
+  /// Returns `true` if [element] can be accessed through reflection, that is,
+  /// is in the set of elements covered by a `MirrorsUsed` annotation.
+  ///
+  /// This property is used to tag emitted elements with a marker which is
+  /// checked by the runtime system to throw an exception if an element is
+  /// accessed (invoked, get, set) that is not accessible for the reflective
+  /// system.
   bool isAccessibleByReflection(Element element) {
     if (element.isClass) {
       element = _getDartClass(element);
     }
     return membersNeededForReflection.contains(element);
   }
 
   ClassElement _getDartClass(ClassElement cls) {
     if (cls == _helpers.jsIntClass) {
       return _commonElements.intClass;
@@ skipping 217 matching lines @@
   // [computeMembersNeededForReflection].
   void maybeMarkClosureAsNeededForReflection(
       ClosureClassElement globalizedElement,
       FunctionElement callFunction,
       FunctionElement function) {
     if (!_membersNeededForReflection.contains(function)) return;
     _membersNeededForReflection.add(callFunction);
     _membersNeededForReflection.add(globalizedElement);
   }
 
-  /// Called when [:const Symbol(name):] is seen.
+  /// 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));
     }
   }
 }