Introduce BackendImpact to separate enqueueing from data.

pkg/compiler/lib/src/js_backend/backend_impact.dart

+// Copyright (c) 2015, 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.js_helpers.impact;
+
+import '../common/names.dart' show
+    Identifiers;
+import '../compiler.dart' show
+    Compiler;
+import '../dart_types.dart' show
+    InterfaceType;
+import '../elements/elements.dart' show
+    ClassElement,
+    Element;
+
+import 'backend_helpers.dart';
+import 'constant_system_javascript.dart';
+import 'js_backend.dart';
+
+/// A set of JavaScript backend dependencies.
+class BackendImpact {
+  final List<Element> staticUses;
+  final List<InterfaceType> instantiatedTypes;
+  final List<ClassElement> instantiatedClasses;
+  final List<BackendImpact> otherImpacts;
+
+  BackendImpact({this.staticUses: const <Element>[],
+                 this.instantiatedTypes: const <InterfaceType>[],
+                 this.instantiatedClasses: const <ClassElement>[],
+                 this.otherImpacts: const <BackendImpact>[]});
+}
+
+/// The JavaScript backend dependencies for various features.
+class BackendImpacts {
+  final Compiler compiler;
+
+  BackendImpacts(this.compiler);
+
+  JavaScriptBackend get backend => compiler.backend;
+
+  BackendHelpers get helpers => backend.helpers;
+
+  BackendImpact get getRuntimeTypeArgument => new BackendImpact(
+      staticUses: [
+        helpers.getRuntimeTypeArgument,
+        helpers.getTypeArgumentByIndex,
+        helpers.copyTypeArguments]);
+
+  BackendImpact get computeSignature => new BackendImpact(
+      staticUses: [
+        helpers.setRuntimeTypeInfo,
+        helpers.getRuntimeTypeInfo,
+        helpers.computeSignature,
+        helpers.getRuntimeTypeArguments],
+      instantiatedClasses: [
+        compiler.listClass]);
+
+  BackendImpact get asyncBody => new BackendImpact(
+      staticUses: [
+        helpers.asyncHelper,
+        helpers.syncCompleterConstructor,
+        helpers.streamIteratorConstructor,
+        helpers.wrapBody]);
+
+  BackendImpact get syncStarBody => new BackendImpact(
+      staticUses: [
+        helpers.syncStarIterableConstructor,
+        helpers.endOfIteration,
+        helpers.yieldStar,
+        helpers.syncStarUncaughtError],
+      instantiatedClasses: [
+        helpers.syncStarIterable]);
+
+  BackendImpact get asyncStarBody => new BackendImpact(
+      staticUses: [
+        helpers.asyncStarHelper,
+        helpers.streamOfController,
+        helpers.yieldSingle,
+        helpers.yieldStar,
+        helpers.asyncStarControllerConstructor,
+        helpers.streamIteratorConstructor,
+        helpers.wrapBody],
+      instantiatedClasses: [
+        helpers.asyncStarController]);
+
+  BackendImpact get typeVariableBoundCheck => new BackendImpact(
+      staticUses: [
+        helpers.throwTypeError,
+        helpers.assertIsSubtype]);
+
+  BackendImpact get abstractClassInstantiation => new BackendImpact(
+      staticUses: [
+        helpers.throwAbstractClassInstantiationError],
+      otherImpacts: [
+        needsString('Needed to encode the message.')]);
+
+  BackendImpact get fallThroughError => new BackendImpact(
+      staticUses: [
+        helpers.fallThroughError]);
+
+  BackendImpact get asCheck => new BackendImpact(
+      staticUses: [
+        helpers.throwRuntimeError]);
+
+  BackendImpact get throwNoSuchMethod => new BackendImpact(
+      staticUses: [
+        helpers.throwNoSuchMethod],
+      otherImpacts: [
+        // Also register the types of the arguments passed to this method.
+        needsList(
+            'Needed to encode the arguments for throw NoSuchMethodError.'),
+        needsString(
+            'Needed to encode the name for throw NoSuchMethodError.')]);
+
+  BackendImpact get throwRuntimeError => new BackendImpact(
+      staticUses: [
+        helpers.throwRuntimeError],
+      // Also register the types of the arguments passed to this method.
+      instantiatedClasses: [
+        helpers.compiler.stringClass]);
+
+  BackendImpact get superNoSuchMethod => new BackendImpact(
+      staticUses: [
+        helpers.createInvocationMirror,
+        helpers.compiler.objectClass.lookupLocalMember(
+            Identifiers.noSuchMethod_)],
+      otherImpacts: [
+        needsInt(
+            'Needed to encode the invocation kind of super.noSuchMethod.'),
+        needsList(
+            'Needed to encode the arguments of super.noSuchMethod.'),
+        needsString(
+            'Needed to encode the name of super.noSuchMethod.')]);
+
+  BackendImpact get constantMapLiteral {
+
+    ClassElement find(String name) {
+      return helpers.find(backend.jsHelperLibrary, name);
+    }
+
+    return new BackendImpact(
+      instantiatedClasses: [
+        find(JavaScriptMapConstant.DART_CLASS),
+        find(JavaScriptMapConstant.DART_PROTO_CLASS),
+        find(JavaScriptMapConstant.DART_STRING_CLASS),
+        find(JavaScriptMapConstant.DART_GENERAL_CLASS)]);
+  }
+
+  BackendImpact get symbolConstructor => new BackendImpact(
+      staticUses: [
+        helpers.compiler.symbolValidatedConstructor]);
+
+
+  BackendImpact get incDecOperation =>
+      needsInt('Needed for the `+ 1` or `- 1` operation of ++/--.');
+
+  /// Helper for registering that `int` is needed.
+  BackendImpact needsInt(String reason) {
+    // TODO(johnniwinther): Register [reason] for use in dump-info.
+    return new BackendImpact(
+        instantiatedClasses: [helpers.compiler.intClass]);
+  }
+
+  /// Helper for registering that `List` is needed.
+  BackendImpact needsList(String reason) {
+    // TODO(johnniwinther): Register [reason] for use in dump-info.
+    return new BackendImpact(
+        instantiatedClasses: [helpers.compiler.listClass]);
+  }
+
+  /// Helper for registering that `String` is needed.
+  BackendImpact needsString(String reason) {
+    // TODO(johnniwinther): Register [reason] for use in dump-info.
+    return new BackendImpact(
+        instantiatedClasses: [
+          helpers.compiler.stringClass]);
+  }
+
+  BackendImpact get assertWithoutMessage => new BackendImpact(
+      staticUses: [
+        helpers.assertHelper]);
+
+  BackendImpact get assertWithMessage => new BackendImpact(
+      staticUses: [
+        helpers.assertTest,
+        helpers.assertThrow]);
+
+  BackendImpact get asyncForIn => new BackendImpact(
+      staticUses: [
+        helpers.streamIteratorConstructor]);
+
+  BackendImpact get stringInterpolation => new BackendImpact(
+      staticUses: [
+        helpers.stringInterpolationHelper]);
+
+  BackendImpact get catchStatement => new BackendImpact(
+      staticUses: [
+        helpers.exceptionUnwrapper],
+      instantiatedClasses: [
+        backend.jsPlainJavaScriptObjectClass,
+        backend.jsUnknownJavaScriptObjectClass]);
+
+  BackendImpact get throwExpression => new BackendImpact(
+      // We don't know ahead of time whether we will need the throw in a
+      // statement context or an expression context, so we register both
+      // here, even though we may not need the throwExpression helper.
+      staticUses: [
+        helpers.wrapExceptionHelper,
+        helpers.throwExpressionHelper]);
+
+  BackendImpact get lazyField => new BackendImpact(
+      staticUses: [
+        helpers.cyclicThrowHelper]);
+
+  BackendImpact get typeLiteral => new BackendImpact(
+      instantiatedClasses: [
+        backend.typeImplementation],
+      staticUses: [
+        helpers.createRuntimeType]);
+
+  BackendImpact get stackTraceInCatch => new BackendImpact(
+      staticUses: [
+        helpers.traceFromException]);
+
+  BackendImpact get syncForIn => new BackendImpact(
+      // The SSA builder recognizes certain for-in loops and can generate calls
+      // to throwConcurrentModificationError.
+      staticUses: [
+        helpers.checkConcurrentModificationError]);
+
+  BackendImpact get typeVariableExpression => new BackendImpact(
+      staticUses: [
+        helpers.setRuntimeTypeInfo,
+        helpers.getRuntimeTypeInfo,
+        helpers.runtimeTypeToString,
+        helpers.createRuntimeType],
+      instantiatedClasses: [
+        helpers.compiler.listClass],
+      otherImpacts: [
+        getRuntimeTypeArgument,
+        needsInt('Needed for accessing a type variable literal on this.')]);
+
+  BackendImpact get typeCheck => new BackendImpact(
+      instantiatedClasses: [
+        helpers.compiler.boolClass]);
+
+  BackendImpact get checkedModeTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.throwRuntimeError]);
+
+  BackendImpact get malformedTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.throwTypeError]);
+
+  BackendImpact get genericTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.checkSubtype,
+        // TODO(johnniwinther): Investigate why this is needed.
+        helpers.setRuntimeTypeInfo,
+        helpers.getRuntimeTypeInfo],
+      instantiatedClasses: [
+        helpers.compiler.listClass],
+      otherImpacts: [
+        getRuntimeTypeArgument]);
+
+  BackendImpact get genericCheckedModeTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.assertSubtype]);
+
+  BackendImpact get typeVariableTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.checkSubtypeOfRuntimeType]);
+
+  BackendImpact get typeVariableCheckedModeTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.assertSubtypeOfRuntimeType]);
+
+  BackendImpact get functionTypeCheck => new BackendImpact(
+      staticUses: [
+        helpers.functionTypeTestMetaHelper]);
+
+  BackendImpact get nativeTypeCheck => new BackendImpact(
+      staticUses: [
+        // We will neeed to add the "$is" and "$as" properties on the
+        // JavaScript object prototype, so we make sure
+        // [:defineProperty:] is compiled.
+        helpers.defineProperty]);
+}