Remove Compiler.inferenceWorld

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 46 matching lines @@
     show
         ImpactStrategy,
         ImpactUseCase,
         TransformedWorldImpact,
         WorldImpact,
         WorldImpactBuilder,
         WorldImpactBuilderImpl,
         WorldImpactVisitor,
         StagedWorldImpactBuilder;
 import '../util/util.dart';
-import '../world.dart' show ClosedWorld;
+import '../world.dart' show ClosedWorld, ClosedWorldRefiner;
 import 'backend_helpers.dart';
 import 'backend_impact.dart';
 import 'backend_serialization.dart' show JavaScriptBackendSerialization;
 import 'checked_mode_helpers.dart';
 import 'constant_handler_javascript.dart';
 import 'custom_elements_analysis.dart';
 import 'enqueuer.dart';
 import 'js_interop_analysis.dart' show JsInteropAnalysis;
 import '../kernel/task.dart';
 import 'lookup_map_analysis.dart' show LookupMapAnalysis;
@@ skipping 1197 matching lines @@
     if (TRACE_CALLS) {
       impactTransformer.registerBackendImpact(
           impactBuilder, impacts.traceHelper);
     }
     impactTransformer.registerBackendImpact(
         impactBuilder, impacts.assertUnreachable);
     _registerCheckedModeHelpers(impactBuilder);
     return impactBuilder;
   }
 
-  onResolutionComplete() {
-    compiler.enqueuer.resolution.processedEntities.forEach(processAnnotations);
-    super.onResolutionComplete();
+  onResolutionComplete(ClosedWorldRefiner closedWorldRefiner) {
+    for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
+      processAnnotations(entity, closedWorldRefiner);
+    }
+    super.onResolutionComplete(closedWorldRefiner);
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
     _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
@@ skipping 1085 matching lines @@
 
   WorldImpact onCodegenStart() {
     lookupMapAnalysis.onCodegenStart();
     if (hasIsolateSupport) {
       return enableIsolateSupport(forResolution: false);
     }
     return const WorldImpact();
   }
 
   /// Process backend specific annotations.
-  void processAnnotations(Element element) {
+  void processAnnotations(
+      Element element, ClosedWorldRefiner closedWorldRefiner) {
     if (element.isMalformed) {
       // Elements that are marked as malformed during parsing or resolution
       // might be registered here. These should just be ignored.
       return;
     }
 
     Element implementation = element.implementation;
     if (element.isFunction || element.isConstructor) {
       if (annotations.noInline(implementation)) {
         inlineCache.markAsNonInlinable(implementation);
@@ skipping 33 matching lines @@
             !element.isFactoryConstructor) {
           reporter.internalError(
               element,
               "@NoThrows() is currently limited to top-level"
               " or static functions and factory constructors.");
         }
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Cannot throw"});
         }
-        compiler.inferenceWorld.registerCannotThrow(element);
+        closedWorldRefiner.registerCannotThrow(element);
       } else if (cls == helpers.noSideEffectsClass) {
         hasNoSideEffects = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           reporter.reportHintMessage(
               element, MessageKind.GENERIC, {'text': "Has no side effects"});
         }
-        compiler.inferenceWorld.registerSideEffectsFree(element);
+        closedWorldRefiner.registerSideEffectsFree(element);
       }
     }
     if (hasForceInline && hasNoInline) {
       reporter.internalError(
           element, "@ForceInline() must not be used with @NoInline.");
     }
     if (hasNoThrows && !hasNoInline) {
       reporter.internalError(
           element, "@NoThrows() should always be combined with @NoInline.");
     }
@@ skipping 764 matching lines @@
       helpers.jsMutableIndexableClass;
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == helpers.coreClasses.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 }