Pass ClosedWorld directly to codegen tasks

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 27 matching lines @@
 import '../io/start_end_information.dart'
     show StartEndSourceInformationStrategy;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js/js_source_mapping.dart' show JavaScriptSourceInformationStrategy;
 import '../js/rewrite_async.dart';
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask;
 import '../library_loader.dart' show LibraryLoader, LoadedLibraries;
 import '../native/native.dart' as native;
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
+import '../tracer.dart';
 import '../tree/tree.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/feature.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart'
     show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
 import '../universe/world_impact.dart'
     show
@@ skipping 23 matching lines @@
 import 'no_such_method_registry.dart';
 import 'patch_resolver.dart';
 import 'type_variable_handler.dart';
 
 part 'runtime_types.dart';
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 abstract class FunctionCompiler {
   /// Generates JavaScript code for `work.element`.
-  jsAst.Fun compile(CodegenWorkItem work);
+  jsAst.Fun compile(CodegenWorkItem work, ClosedWorld closedWorld);
 
   Iterable get tasks;
 }
 
 /*
  * Invariants:
  *   canInline(function) implies canInline(function, insideLoop:true)
  *   !canInline(function, insideLoop: true) implies !canInline(function)
  */
 class FunctionInlineCache {
@@ skipping 450 matching lines @@
       new StagedWorldImpactBuilder();
 
   final NativeData nativeData = new NativeData();
 
   final BackendHelpers helpers;
   final BackendImpacts impacts;
   BackendClasses backendClasses;
 
   final JSFrontendAccess frontend;
 
+  Tracer tracer;
+
   JavaScriptBackend(Compiler compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useNewSourceInfo: false,
       bool useKernel: false})
       : oneShotInterceptors = new Map<jsAst.Name, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new _RuntimeTypes(compiler),
         rtiEncoder = new _RuntimeTypesEncoder(compiler),
         specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
@@ skipping 319 matching lines @@
       return elements
           .where((element) => classesMixedIntoInterceptedClasses
               .contains(element.enclosingClass))
           .toSet();
     });
 
     if (elements == null) return false;
     if (elements.isEmpty) return false;
     return elements.any((element) {
       return selector.applies(element) &&
-          (mask == null ||
-              mask.canHit(element, selector, compiler.closedWorld));
+          (mask == null || mask.canHit(element, selector, _closedWorld));
     });
   }
 
   /// True if the given class is an internal class used for type inference
   /// and never exists at runtime.
   bool isCompileTimeOnlyClass(ClassElement class_) {
     return class_ == helpers.jsPositiveIntClass ||
         class_ == helpers.jsUInt32Class ||
         class_ == helpers.jsUInt31Class ||
         class_ == helpers.jsFixedArrayClass ||
@@ skipping 35 matching lines @@
           Set<ClassElement> nativeSubclasses =
               nativeSubclassesOfMixin(classElement);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
       }
       return result;
     });
   }
 
   Set<ClassElement> nativeSubclassesOfMixin(ClassElement mixin) {
-    ClosedWorld closedWorld = compiler.closedWorld;
-    Iterable<MixinApplicationElement> uses = closedWorld.mixinUsesOf(mixin);
+    Iterable<MixinApplicationElement> uses = _closedWorld.mixinUsesOf(mixin);
     Set<ClassElement> result = null;
     for (MixinApplicationElement use in uses) {
-      closedWorld.forEachStrictSubclassOf(use, (ClassElement subclass) {
+      _closedWorld.forEachStrictSubclassOf(use, (ClassElement subclass) {
         if (isNativeOrExtendsNative(subclass)) {
           if (result == null) result = new Set<ClassElement>();
           result.add(subclass);
         }
       });
     }
     return result;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
@@ skipping 519 matching lines @@
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         work.registry.worldImpact.registerStaticUse(new StaticUse.staticInvoke(
             helpers.cyclicThrowHelper, CallStructure.ONE_ARG));
       }
     }
 
-    jsAst.Fun function = functionCompiler.compile(work);
+    jsAst.Fun function = functionCompiler.compile(work, _closedWorld);
     if (function.sourceInformation == null) {
       function = function.withSourceInformation(
           sourceInformationStrategy.buildSourceMappedMarker());
     }
     generatedCode[element] = function;
     WorldImpact worldImpact =
         impactTransformer.transformCodegenImpact(work.registry.worldImpact);
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
@@ skipping 232 matching lines @@
         element == helpers.jsUnmodifiableArrayClass;
   }
 
   bool mayGenerateInstanceofCheck(DartType type) {
     // We can use an instanceof check for raw types that have no subclass that
     // is mixed-in or in an implements clause.
 
     if (!type.isRaw) return false;
     ClassElement classElement = type.element;
     if (isInterceptorClass(classElement)) return false;
-    return compiler.closedWorld.hasOnlySubclasses(classElement);
+    return _closedWorld.hasOnlySubclasses(classElement);
   }
 
   WorldImpact registerUsedElement(Element element, {bool forResolution}) {
     WorldImpactBuilderImpl worldImpact = new WorldImpactBuilderImpl();
     if (element == helpers.disableTreeShakingMarker) {
       isTreeShakingDisabled = true;
     } else if (element == helpers.preserveNamesMarker) {
       mustPreserveNames = true;
     } else if (element == helpers.preserveMetadataMarker) {
       mustRetainMetadata = true;
@@ skipping 589 matching lines @@
     }
 
     entities.forEach(processElementMetadata);
   }
 
   void onQueueClosed() {
     lookupMapAnalysis.onQueueClosed();
     jsInteropAnalysis.onQueueClosed();
   }
 
+  // TODO(johnniwinther): Create a CodegenPhase object for the backend to hold
+  // data only available during code generation.
+  ClosedWorld _closedWorldCache;
+  ClosedWorld get _closedWorld {
+    assert(invariant(NO_LOCATION_SPANNABLE, _closedWorldCache != null,
+        message: "ClosedWorld has not be set yet."));
+    return _closedWorldCache;
+  }
+
+  void set _closedWorld(ClosedWorld value) {
+    _closedWorldCache = value;
+  }
+
   WorldImpact onCodegenStart(ClosedWorld closedWorld) {
-    _namer = determineNamer(closedWorld);
-    emitter.createEmitter(_namer, closedWorld);
+    _closedWorld = closedWorld;
+    _namer = determineNamer(_closedWorld);
+    tracer = new Tracer(_closedWorld, namer, compiler.outputProvider);
+    emitter.createEmitter(_namer, _closedWorld);
     lookupMapAnalysis.onCodegenStart();
     if (hasIsolateSupport) {
       return enableIsolateSupport(forResolution: false);
     }
     return const WorldImpact();
   }
 
+  void onCodegenEnd() {
+    sourceInformationStrategy.onComplete();
+    tracer.close();
+  }
+
   /// Process backend specific annotations.
   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;
@@ skipping 840 matching lines @@
   @override
   bool isInterceptorClass(ClassElement cls) {
     return helpers.backend.isInterceptorClass(cls);
   }
 
   @override
   bool isNative(Element element) {
     return helpers.backend.isNative(element);
   }
 }