Remove use of Compiler in inferrer engines.

pkg/compiler/lib/src/inferrer/inferrer_engine.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 'package:kernel/ast.dart' as ir;
 
+import '../../compiler_new.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../common_elements.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Elements,
         MemberElement,
         ParameterElement;
 import '../elements/entities.dart';
 import '../elements/names.dart';
 import '../js_backend/annotations.dart';
-import '../js_backend/js_backend.dart';
+import '../js_backend/mirrors_data.dart';
+import '../js_backend/no_such_method_registry.dart';
 import '../native/behavior.dart' as native;
+import '../options.dart';
 import '../types/constants.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../util/setlet.dart';
 import '../world.dart';
 import 'closure_tracer.dart';
 import 'debug.dart' as debug;
 import 'locals_handler.dart';
@@ skipping 16 matching lines @@
     new Selector.getter(const PublicName('first')),
     new Selector.getter(const PublicName('last')),
     new Selector.getter(const PublicName('single')),
     new Selector.call(const PublicName('singleWhere'), CallStructure.ONE_ARG),
     new Selector.call(const PublicName('elementAt'), CallStructure.ONE_ARG),
     new Selector.index(),
     new Selector.call(const PublicName('removeAt'), CallStructure.ONE_ARG),
     new Selector.call(const PublicName('removeLast'), CallStructure.NO_ARGS)
   ]);
 
-  Compiler get compiler;
+  CompilerOptions get options;
   ClosedWorld get closedWorld;
   ClosedWorldRefiner get closedWorldRefiner;
-  JavaScriptBackend get backend => compiler.backend;
-  OptimizerHintsForTests get optimizerHints => backend.optimizerHints;
-  DiagnosticReporter get reporter => compiler.reporter;
+  OptimizerHintsForTests get optimizerHints;
+  DiagnosticReporter get reporter;
   CommonMasks get commonMasks => closedWorld.commonMasks;
   CommonElements get commonElements => closedWorld.commonElements;
 
+  // TODO(johnniwinther): This should be part of [ClosedWorld] or
+  // [ClosureWorldRefiner].
+  NoSuchMethodRegistry get noSuchMethodRegistry;
+
   TypeSystem<T> get types;
   Map<T, TypeInformation> get concreteTypes;
 
   FunctionEntity get mainElement;
 
   void runOverAllElements();
 
   void analyze(MemberEntity member, T node, ArgumentsTypes arguments);
   void analyzeListAndEnqueue(ListTypeInformation info);
   void analyzeMapAndEnqueue(MapTypeInformation info);
@@ skipping 137 matching lines @@
 
   /// Returns the type for [nativeBehavior]. See documentation on
   /// [native.NativeBehavior].
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior);
 
   bool returnsListElementType(Selector selector, TypeMask mask);
 
   bool returnsMapValueType(Selector selector, TypeMask mask);
 
   void clear();
+
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the field [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
+  bool canFieldBeUsedForGlobalOptimizations(FieldEntity element);
+
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the parameter [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
+  bool canFunctionParametersBeUsedForGlobalOptimizations(
+      FunctionEntity function);
 }
 
 abstract class InferrerEngineImpl<T> extends InferrerEngine<T> {
   final Map<Local, TypeInformation> defaultTypeOfParameter =
       new Map<Local, TypeInformation>();
   final WorkQueue workQueue = new WorkQueue();
   final FunctionEntity mainElement;
   final Set<MemberEntity> analyzedElements = new Set<MemberEntity>();
 
   /// The maximum number of times we allow a node in the graph to
   /// change types. If a node reaches that limit, we give up
   /// inferencing on it and give it the dynamic type.
   final int MAX_CHANGE_COUNT = 6;
 
   int overallRefineCount = 0;
   int addedInGraph = 0;
 
-  final Compiler compiler;
+  final CompilerOptions options;
+  final Progress progress;
+  final DiagnosticReporter reporter;
+  final CompilerOutput _compilerOutput;
+  final OptimizerHintsForTests optimizerHints;
 
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
   final TypeSystem<T> types;
   final Map<T, TypeInformation> concreteTypes = new Map<T, TypeInformation>();
 
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
   final Set<ConstructorEntity> generativeConstructorsExposingThis =
       new Set<ConstructorEntity>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<MemberEntity, GlobalTypeInferenceElementData> _memberData =
       new Map<MemberEntity, GlobalTypeInferenceElementData>();
 
+  // TODO(johnniwinther): This should be accessible throught [closedWorld].
+  final MirrorsData mirrorsData;
+
+  final NoSuchMethodRegistry noSuchMethodRegistry;
+
   InferrerEngineImpl(
-      this.compiler,
-      ClosedWorld closedWorld,
+      this.options,
+      this.progress,
+      this.reporter,
+      this._compilerOutput,
+      this.optimizerHints,
+      this.closedWorld,
       this.closedWorldRefiner,
+      this.mirrorsData,
+      this.noSuchMethodRegistry,
       this.mainElement,
       TypeSystemStrategy<T> typeSystemStrategy)
-      : this.types = new TypeSystem<T>(closedWorld, typeSystemStrategy),
-        this.closedWorld = closedWorld;
+      : this.types = new TypeSystem<T>(closedWorld, typeSystemStrategy);
 
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(MemberEntity element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
     for (MemberEntity e in elements) {
       if (!f(e)) return;
     }
   }
 
   GlobalTypeInferenceElementData<T> createElementData();
@@ skipping 170 matching lines @@
     }
 
     info.markAsInferred();
     workQueue.add(info.keyType);
     workQueue.add(info.valueType);
     workQueue.addAll(info.typeInfoMap.values);
     workQueue.add(info);
   }
 
   void runOverAllElements() {
-    if (compiler.disableTypeInference) return;
-    if (compiler.options.verbose) {
-      compiler.progress.reset();
-    }
+    progress.startPhase();
+
     analyzeAllElements();
 
-    TypeGraphDump dump = debug.PRINT_GRAPH ? new TypeGraphDump(this) : null;
+    TypeGraphDump dump =
+        debug.PRINT_GRAPH ? new TypeGraphDump(_compilerOutput, this) : null;
 
     dump?.beforeAnalysis();
     buildWorkQueue();
     refine();
 
     // Try to infer element types of lists and compute their escape information.
     types.allocatedLists.values.forEach((TypeInformation info) {
       analyzeListAndEnqueue(info);
     });
 
@@ skipping 146 matching lines @@
 
     reporter.log('Inferred $overallRefineCount types.');
 
     processLoopInformation();
   }
 
   /// Call [analyze] for all live members.
   void analyzeAllElements() {
     sortMembers(closedWorld.processedMembers, computeMemberSize)
         .forEach((MemberEntity member) {
-      if (compiler.shouldPrintProgress) {
-        reporter.log('Added $addedInGraph elements in inferencing graph.');
-        compiler.progress.reset();
-      }
+      progress.showProgress(
+          'Added ', addedInGraph, ' elements in inferencing graph.');
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
       T body = computeMemberBody(member);
       types.withMember(member, () => analyze(member, body, null));
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
   }
 
   /// Compute a 'size' of [member] used for sorting member for the type
   /// inference work-queue. Smallest members are processed first.
@@ skipping 93 matching lines @@
         // on the code bloat.
         info.targets.forEach((MemberEntity element) {
           closedWorldRefiner.addFunctionCalledInLoop(element);
         });
       }
     });
   }
 
   void refine() {
     while (!workQueue.isEmpty) {
-      if (compiler.shouldPrintProgress) {
-        reporter.log('Inferred $overallRefineCount types.');
-        compiler.progress.reset();
-      }
+      progress.showProgress('Inferred ', overallRefineCount, ' types.');
       TypeInformation info = workQueue.remove();
       TypeMask oldType = info.type;
       TypeMask newType = info.refine(this);
       // Check that refinement has not accidentally changed the type.
       assert(oldType == info.type);
       if (info.abandonInferencing) info.doNotEnqueue = true;
       if ((info.type = newType) != oldType) {
         overallRefineCount++;
         info.refineCount++;
         if (info.refineCount > MAX_CHANGE_COUNT) {
@@ skipping 300 matching lines @@
     types.allocatedClosures.clear();
 
     analyzedElements.clear();
     generativeConstructorsExposingThis.clear();
 
     types.allocatedMaps.values.forEach(cleanup);
     types.allocatedLists.values.forEach(cleanup);
   }
 
   Iterable<MemberEntity> getCallersOf(MemberEntity element) {
-    if (compiler.disableTypeInference) {
-      throw new UnsupportedError(
-          "Cannot query the type inferrer when type inference is disabled.");
-    }
     MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callers;
   }
 
   TypeInformation typeOfMemberWithSelector(
       covariant MemberElement element, Selector selector) {
     if (element.name == Identifiers.noSuchMethod_ &&
         selector.name != element.name) {
       // An invocation can resolve to a [noSuchMethod], in which case
       // we get the return type of [noSuchMethod].
@@ skipping 13 matching lines @@
         return returnTypeOfMember(element);
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       return types.dynamicType;
     } else {
       return returnTypeOfMember(element);
     }
   }
 
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the field [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
+  bool canFieldBeUsedForGlobalOptimizations(FieldEntity element) {
+    if (closedWorld.backendUsage.isFieldUsedByBackend(element)) {
+      return false;
+    }
+    if ((element.isTopLevel || element.isStatic) && !element.isAssignable) {
+      return true;
+    }
+    return !mirrorsData.isMemberAccessibleByReflection(element);
+  }
+
+  /// Returns true if global optimizations such as type inferencing can apply to
+  /// the parameter [element].
+  ///
+  /// One category of elements that do not apply is runtime helpers that the
+  /// backend calls, but the optimizations don't see those calls.
+  bool canFunctionParametersBeUsedForGlobalOptimizations(
+      FunctionEntity function) {
+    return !closedWorld.backendUsage.isFunctionUsedByBackend(function) &&
+        !mirrorsData.isMemberAccessibleByReflection(function);
+  }
+
   // Sorts the resolved elements by size. We do this for this inferrer
   // to get the same results for [ListTracer] compared to the
   // [SimpleTypesInferrer].
   static Iterable<MemberEntity> sortMembers(
       Iterable<MemberEntity> members, int computeSize(MemberEntity member)) {
     Map<int, Set<MemberEntity>> methodSizes =
         groupMembers(members, computeSize);
     int max = methodSizes.keys.fold(0, (a, b) => a > b ? a : b);
     List<MemberEntity> result = <MemberEntity>[];
     for (int i = 0; i <= max; i++) {
@@ skipping 11 matching lines @@
       // Put the other operators in buckets by size, later to be added in
       // size order.
       int size = computeSize(element);
       Set<MemberEntity> set =
           methodSizes.putIfAbsent(size, () => new Setlet<MemberEntity>());
       set.add(element);
     });
     return methodSizes;
   }
 }