Access BackendUsage through ClosedWorld

pkg/compiler/lib/src/world.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.
 
 library dart2js.world;
 
 import 'closure.dart' show ClosureClassElement, SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'constants/constant_system.dart';
 import 'common_elements.dart' show CommonElements;
@@ skipping 24 matching lines @@
 
 /// The [ClosedWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
 /// it, what functions are called, what classes are allocated, which native
 /// JavaScript types are touched, what language features are used, and so on.
 /// This precise knowledge about what's live in the program is later used in
 /// optimizations and other compiler decisions during code generation.
 abstract class ClosedWorld implements World {
+  BackendUsage get backendUsage;
+
   NativeData get nativeData;
 
   InterceptorData get interceptorData;
 
   CommonElements get commonElements;
 
   CommonMasks get commonMasks;
 
   ConstantSystem get constantSystem;
 
@@ skipping 335 matching lines @@
 
   /// The class and all classes that implement or subclass it (transitively)
   /// are included.
   SUBTYPE,
 }
 
 abstract class ClosedWorldBase implements ClosedWorld, ClosedWorldRefiner {
   final ConstantSystem constantSystem;
   final NativeData nativeData;
   final InterceptorData interceptorData;
-  final BackendUsage _backendUsage;
+  final BackendUsage backendUsage;
 
   final FunctionSet _allFunctions;
 
   final Iterable<TypedefElement> _allTypedefs;
 
   final Map<ClassEntity, Set<ClassEntity>> _mixinUses;
   Map<ClassEntity, List<ClassEntity>> _liveMixinUses;
 
   final Map<ClassEntity, Set<ClassEntity>> _typesImplementedBySubclasses;
 
@@ skipping 18 matching lines @@
 
   final CommonElements commonElements;
 
   final ResolutionWorldBuilder _resolverWorld;
 
   ClosedWorldBase(
       {this.commonElements,
       this.constantSystem,
       this.nativeData,
       this.interceptorData,
-      BackendUsage backendUsage,
+      this.backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       FunctionSet functionSet,
       Iterable<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
-      : this._backendUsage = backendUsage,
-        this._resolverWorld = resolutionWorldBuilder,
+      : this._resolverWorld = resolutionWorldBuilder,
         this._allFunctions = functionSet,
         this._allTypedefs = allTypedefs,
         this._mixinUses = mixinUses,
         this._typesImplementedBySubclasses = typesImplementedBySubclasses,
         this._classHierarchyNodes = classHierarchyNodes,
         this._classSets = classSets {
     _commonMasks = new CommonMasks(this);
   }
 
   @override
@@ skipping 538 matching lines @@
   }
 
   MemberEntity locateSingleElement(Selector selector, TypeMask mask) {
     mask ??= commonMasks.dynamicType;
     return mask.locateSingleElement(selector, this);
   }
 
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
     bool canReachAll = true;
     if (mask != null) {
-      canReachAll = _backendUsage.isInvokeOnUsed &&
+      canReachAll = backendUsage.isInvokeOnUsed &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
     return canReachAll ? commonMasks.dynamicType : mask;
   }
 
   bool fieldNeverChanges(MemberEntity element) {
     if (!element.isField) return false;
     if (nativeData.isNativeMember(element)) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
@@ skipping 339 matching lines @@
   @override
   void registerClosureClass(ClassElement cls) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
 
   @override
   bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
     throw new UnimplementedError('KernelClosedWorld.hasElementIn');
   }
 }