Introduce BackendImpact to separate enqueueing from data.

pkg/compiler/lib/src/common/resolution.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.common.resolution;
 
 import '../compiler.dart' show
     Compiler;
 import '../core_types.dart' show
@@ skipping 47 matching lines @@
     return impact;
   }
 
   bool get isAnalyzed => _isAnalyzed;
 }
 
 // TODO(johnniwinther): Rename this to something like  `BackendResolutionApi`
 // and clean up the interface.
 /// Backend callbacks function specific to the resolution phase.
 class ResolutionCallbacks {
-  ///
+  /// Transform the [ResolutionWorldImpact] into a [WorldImpact] adding the
+  /// backend dependencies for features used in [worldImpact].
   WorldImpact transformImpact(ResolutionWorldImpact worldImpact) => worldImpact;
-
-  /// Register that an assert has been seen.
-  void onAssert(bool hasMessage, Registry registry) {}
-
-  /// Register that an 'await for' has been seen.
-  void onAsyncForIn(AsyncForIn node, Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program uses string interpolation.
-  void onStringInterpolation(Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program has a catch statement.
-  void onCatchStatement(Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program explicitly throws an exception.
-  void onThrowExpression(Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program has a global variable with a lazy initializer.
-  void onLazyField(Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program uses a type variable as an expression.
-  void onTypeVariableExpression(Registry registry,
-                                TypeVariableElement variable) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program uses a type literal.
-  void onTypeLiteral(DartType type, Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program has a catch statement with a stack trace.
-  void onStackTraceInCatch(Registry registry) {}
-
-  /// Register an is check to the backend.
-  void onIsCheck(DartType type, Registry registry) {}
-
-  /// Called during resolution to notify to the backend that the
-  /// program has a for-in loop.
-  void onSyncForIn(Registry registry) {}
-
-  /// Register an as check to the backend.
-  void onAsCheck(DartType type, Registry registry) {}
-
-  /// Registers that a type variable bounds check might occur at runtime.
-  void onTypeVariableBoundCheck(Registry registry) {}
-
-  /// Register that the application may throw a [NoSuchMethodError].
-  void onThrowNoSuchMethod(Registry registry) {}
-
-  /// Register that the application may throw a [RuntimeError].
-  void onThrowRuntimeError(Registry registry) {}
-
-  /// Register that the application has a compile time error.
-  void onCompileTimeError(Registry registry, ErroneousElement error) {}
-
-  /// Register that the application may throw an
-  /// [AbstractClassInstantiationError].
-  void onAbstractClassInstantiation(Registry registry) {}
-
-  /// Register that the application may throw a [FallThroughError].
-  void onFallThroughError(Registry registry) {}
-
-  /// Register that a super call will end up calling
-  /// [: super.noSuchMethod :].
-  void onSuperNoSuchMethod(Registry registry) {}
-
-  /// Register that the application creates a constant map.
-  void onMapLiteral(Registry registry, DartType type, bool isConstant) {}
-
-  /// Called when resolving the `Symbol` constructor.
-  void onSymbolConstructor(Registry registry) {}
-
-  /// Called when resolving a prefix or postfix expression.
-  void onIncDecOperation(Registry registry) {}
 }
 
 class ResolutionWorldImpact extends WorldImpact {
   const ResolutionWorldImpact();
 
   // TODO(johnniwinther): Remove this.
   void registerDependency(Element element) {}
 
   Iterable<Feature> get features => const <Feature>[];
   Iterable<DartType> get requiredTypes => const <DartType>[];
@@ skipping 21 matching lines @@
   /// A catch statement.
   CATCH_STATEMENT,
   /// A compile time error.
   COMPILE_TIME_ERROR,
   /// A fall through in a switch case.
   FALL_THROUGH_ERROR,
   /// A ++/-- operation.
   INC_DEC_OPERATION,
   /// A field whose initialization is not a constant.
   LAZY_FIELD,
-  /// A call to `new Symbol`.
-  NEW_SYMBOL,
   /// A catch clause with a variable for the stack trace.
   STACK_TRACE_IN_CATCH,
   /// String interpolation.
   STRING_INTERPOLATION,
   /// An implicit call to `super.noSuchMethod`, like calling an unresolved
   /// super method.
   SUPER_NO_SUCH_METHOD,
   /// A redirection to the `Symbol` constructor.
   SYMBOL_CONSTRUCTOR,
   /// An synchronous for in statement, like `for (var e in i) {}`.
@@ skipping 59 matching lines @@
         type == other.type &&
         isConstant == other.isConstant &&
         isEmpty == other.isEmpty;
   }
 }
 
 /// Mutable implementation of [WorldImpact] used to transform
 /// [ResolutionWorldImpact] to [WorldImpact].
 // TODO(johnniwinther): Remove [Registry] when dependency is tracked directly
 // on [WorldImpact].
-class TransformedWorldImpact implements WorldImpact, Registry {
+class TransformedWorldImpact implements WorldImpact {
   final ResolutionWorldImpact worldImpact;
 
   Setlet<Element> _staticUses;
   Setlet<InterfaceType> _instantiatedTypes;
   Setlet<UniverseSelector> _dynamicGetters;
   Setlet<UniverseSelector> _dynamicInvocations;
   Setlet<UniverseSelector> _dynamicSetters;
 
   TransformedWorldImpact(this.worldImpact);
 
@@ skipping 30 matching lines @@
   Iterable<DartType> get isChecks => worldImpact.isChecks;
 
   @override
   Iterable<Element> get staticUses {
     if (_staticUses == null) {
       return worldImpact.staticUses;
     }
     return _staticUses;
   }
 
-  @override
-  bool get isForResolution => true;
-
   _unsupported(String message) => throw new UnsupportedError(message);
 
-  @override
-  Iterable<Element> get otherDependencies => _unsupported('otherDependencies');
-
-  // TODO(johnniwinther): Remove this.
-  @override
-  void registerAssert(bool hasMessage) => _unsupported('registerAssert');
-
-  @override
-  void registerDependency(Element element) {
-    worldImpact.registerDependency(element);
-  }
-
-  @override
   void registerDynamicGetter(UniverseSelector selector) {
     if (_dynamicGetters == null) {
       _dynamicGetters = new Setlet<UniverseSelector>();
       _dynamicGetters.addAll(worldImpact.dynamicGetters);
     }
     _dynamicGetters.add(selector);
   }
 
-  @override
   void registerDynamicInvocation(UniverseSelector selector) {
     if (_dynamicInvocations == null) {
       _dynamicInvocations = new Setlet<UniverseSelector>();
       _dynamicInvocations.addAll(worldImpact.dynamicInvocations);
     }
     _dynamicInvocations.add(selector);
   }
 
-  @override
   void registerDynamicSetter(UniverseSelector selector) {
     if (_dynamicSetters == null) {
       _dynamicSetters = new Setlet<UniverseSelector>();
       _dynamicSetters.addAll(worldImpact.dynamicSetters);
     }
     _dynamicSetters.add(selector);
   }
 
-  @override
-  void registerGetOfStaticFunction(FunctionElement element) {
-    _unsupported('registerGetOfStaticFunction($element)');
-  }
-
-  @override
-  void registerInstantiation(InterfaceType type) {
+  void registerInstantiatedType(InterfaceType type) {
     // TODO(johnniwinther): Remove this when dependency tracking is done on
     // the world impact itself.
-    registerDependency(type.element);
+    worldImpact.registerDependency(type.element);
     if (_instantiatedTypes == null) {
       _instantiatedTypes = new Setlet<InterfaceType>();
     }
     _instantiatedTypes.add(type);
   }
 
   @override
   Iterable<InterfaceType> get instantiatedTypes {
     return _instantiatedTypes != null
         ? _instantiatedTypes : const <InterfaceType>[];
   }
 
-  @override
-  void registerStaticInvocation(Element element) {
+  void registerStaticUse(Element element) {
     // TODO(johnniwinther): Remove this when dependency tracking is done on
     // the world impact itself.
-    registerDependency(element);
+    worldImpact.registerDependency(element);
     if (_staticUses == null) {
       _staticUses = new Setlet<Element>();
     }
     _staticUses.add(element);
   }
 
   @override
   Iterable<LocalFunctionElement> get closures => worldImpact.closures;
 }
 
@@ skipping 13 matching lines @@
   bool hasBeenResolved(Element element);
   ResolutionWorldImpact analyzeElement(Element element);
 }
 
 // TODO(johnniwinther): Rename to `Parser` or `ParsingContext`.
 abstract class Parsing {
   DiagnosticReporter get reporter;
   void parsePatchClass(ClassElement cls);
   measure(f());
 }