Extract interface of InferrerEngine and move implemation to InferrerEngineImpl

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 '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 19 matching lines @@
 import 'locals_handler.dart';
 import 'list_tracer.dart';
 import 'map_tracer.dart';
 import 'builder.dart';
 import 'builder_kernel.dart';
 import 'type_graph_dump.dart';
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
-/**
- * An inferencing engine that computes a call graph of
- * [TypeInformation] nodes by visiting the AST of the application, and
- * then does the inferencing on the graph.
- */
-class InferrerEngine {
+/// An inferencing engine that computes a call graph of [TypeInformation] nodes
+/// by visiting the AST of the application, and then does the inferencing on the
+/// graph.
+abstract class InferrerEngine {
+  /// A set of selector names that [List] implements, that we know return their
+  /// element type.
+  final Set<Selector> returnsListElementTypeSet =
+      new Set<Selector>.from(<Selector>[
+    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;
+  ClosedWorld get closedWorld;
+  ClosedWorldRefiner get closedWorldRefiner;
+  JavaScriptBackend get backend => compiler.backend;
+  OptimizerHintsForTests get optimizerHints => backend.optimizerHints;
+  DiagnosticReporter get reporter => compiler.reporter;
+  CommonMasks get commonMasks => closedWorld.commonMasks;
+  CommonElements get commonElements => closedWorld.commonElements;
+
+  TypeSystem<ast.Node> get types;
+  Map<ast.Node, TypeInformation> get concreteTypes;
+
+  /// Parallel structure for concreteTypes.
+  // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
+  // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
+  Map<ir.Node, TypeInformation> get concreteKernelTypes;
+
+  FunctionEntity get mainElement;
+
+  void runOverAllElements();
+
+  void analyze(ResolvedAst resolvedAst, ArgumentsTypes arguments);
+  void analyzeListAndEnqueue(ListTypeInformation info);
+  void analyzeMapAndEnqueue(MapTypeInformation info);
+
+  /// Notifies to the inferrer that [analyzedElement] can have return type
+  /// [newType]. [currentType] is the type the [ElementGraphBuilder] currently
+  /// found.
+  ///
+  /// Returns the new type for [analyzedElement].
+  TypeInformation addReturnTypeForMethod(
+      MethodElement element, TypeInformation unused, TypeInformation newType);
+
+  /// Applies [f] to all elements in the universe that match [selector] and
+  /// [mask]. If [f] returns false, aborts the iteration.
+  void forEachElementMatching(
+      Selector selector, TypeMask mask, bool f(Element element));
+
+  /// Returns the [TypeInformation] node for the default value of a parameter.
+  /// If this is queried before it is set by [setDefaultTypeOfParameter], a
+  /// [PlaceholderTypeInformation] is returned, which will later be replaced
+  /// by the actual node when [setDefaultTypeOfParameter] is called.
+  ///
+  /// Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
+  /// should be present and a default type for each parameter should exist.
+  TypeInformation getDefaultTypeOfParameter(ParameterElement parameter);
+
+  /// This helper breaks abstractions but is currently required to work around
+  /// the wrong modeling of default values of optional parameters of
+  /// synthetic constructors.
+  ///
+  /// TODO(johnniwinther): Remove once default values of synthetic parameters
+  /// are fixed.
+  bool hasAlreadyComputedTypeOfParameterDefault(ParameterElement parameter);
+
+  /// Sets the type of a parameter's default value to [type]. If the global
+  /// mapping in [defaultTypeOfParameter] already contains a type, it must be
+  /// a [PlaceholderTypeInformation], which will be replaced. All its uses are
+  /// updated.
+  void setDefaultTypeOfParameter(
+      ParameterElement parameter, TypeInformation type);
+
+  Iterable<MemberEntity> getCallersOf(MemberElement element);
+
+  // TODO(johnniwinther): Make this private again.
+  GlobalTypeInferenceElementData dataOfMember(MemberElement element);
+
+  GlobalTypeInferenceElementData lookupDataOfMember(MemberElement element);
+
+  bool checkIfExposesThis(ConstructorElement element);
+
+  void recordExposesThis(ConstructorElement element, bool exposesThis);
+
+  /// Records that the return type [element] is of type [type].
+  void recordReturnType(MethodElement element, TypeInformation type);
+
+  /// Records that [element] is of type [type].
+  // TODO(johnniwinther): Merge [recordTypeOfFinalField] and
+  // [recordTypeOfNonFinalField] with this?
+  void recordTypeOfField(FieldElement element, TypeInformation type);
+
+  /// Records that [node] sets final field [element] to be of type [type].
+  void recordTypeOfFinalField(FieldElement element, TypeInformation type);
+
+  /// Records that [node] sets non-final field [element] to be of type [type].
+  void recordTypeOfNonFinalField(FieldElement element, TypeInformation type);
+
+  /// Records that the captured variable [local] is read.
+  // TODO(johnniwinther): Remove this.
+  void recordCapturedLocalRead(Local local) {}
+
+  /// Records that the variable [local] is being updated.
+  // TODO(johnniwinther): Remove this.
+  void recordLocalUpdate(Local local, TypeInformation type) {}
+
+  /// Registers a call to await with an expression of type [argumentType] as
+  /// argument.
+  TypeInformation registerAwait(ast.Node node, TypeInformation argument);
+
+  /// Registers a call to yield with an expression of type [argumentType] as
+  /// argument.
+  TypeInformation registerYield(ast.Node node, TypeInformation argument);
+
+  /// Registers that [caller] calls [closure] with [arguments].
+  ///
+  /// [sideEffects] will be updated to incorporate the potential callees' side
+  /// effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
+  TypeInformation registerCalledClosure(
+      ast.Node node,
+      Selector selector,
+      TypeMask mask,
+      TypeInformation closure,
+      MemberElement caller,
+      ArgumentsTypes arguments,
+      SideEffects sideEffects,
+      bool inLoop);
+
+  /// Registers that [caller] calls [callee] at location [node], with
+  /// [selector], and [arguments]. Note that [selector] is null for forwarding
+  /// constructors.
+  ///
+  /// [sideEffects] will be updated to incorporate [callee]'s side effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
+  TypeInformation registerCalledMember(
+      Spannable node,
+      Selector selector,
+      TypeMask mask,
+      MemberElement caller,
+      MemberElement callee,
+      ArgumentsTypes arguments,
+      SideEffects sideEffects,
+      bool inLoop);
+
+  /// Registers that [caller] calls [selector] with [receiverType] as receiver,
+  /// and [arguments].
+  ///
+  /// [sideEffects] will be updated to incorporate the potential callees' side
+  /// effects.
+  ///
+  /// [inLoop] tells whether the call happens in a loop.
+  TypeInformation registerCalledSelector(
+      ast.Node node,
+      Selector selector,
+      TypeMask mask,
+      TypeInformation receiverType,
+      MemberElement caller,
+      ArgumentsTypes arguments,
+      SideEffects sideEffects,
+      bool inLoop,
+      bool isConditional);
+
+  /// Update the assignments to parameters in the graph. [remove] tells whether
+  /// assignments must be added or removed. If [init] is false, parameters are
+  /// added to the work queue.
+  void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
+      ArgumentsTypes arguments, Selector selector, TypeMask mask,
+      {bool remove, bool addToQueue: true});
+
+  void updateSelectorInMember(
+      MemberElement owner, Spannable node, Selector selector, TypeMask mask);
+
+  /// Returns the return type of [element].
+  TypeInformation returnTypeOfMember(MemberElement element);
+
+  /// Returns the type of [element] when being called with [selector].
+  TypeInformation typeOfMemberWithSelector(
+      MemberElement element, Selector selector);
+
+  /// Returns the type of [element].
+  TypeInformation typeOfMember(MemberElement element);
+
+  /// Returns the type of [element].
+  TypeInformation typeOfParameter(ParameterElement element);
+
+  /// 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();
+}
+
+class InferrerEngineImpl extends InferrerEngine {
   final Map<ParameterElement, TypeInformation> defaultTypeOfParameter =
       new Map<ParameterElement, TypeInformation>();
   final WorkQueue workQueue = new WorkQueue();
   final FunctionEntity mainElement;
   final Set<MemberElement> analyzedElements = new Set<MemberElement>();
 
   /// 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;
 
   /// The [ClosedWorld] on which inference reasoning is based.
   final ClosedWorld closedWorld;
 
   final ClosedWorldRefiner closedWorldRefiner;
   final TypeSystem<ast.Node> types;
   final Map<ast.Node, TypeInformation> concreteTypes =
       new Map<ast.Node, TypeInformation>();
 
-  /// Parallel structure for concreteTypes.
-  // TODO(efortuna): Remove concreteTypes and/or parameterize InferrerEngine by
-  // ir.Node or ast.Node type. Then remove this in favor of `concreteTypes`.
   final Map<ir.Node, TypeInformation> concreteKernelTypes =
       new Map<ir.Node, TypeInformation>();
   final Set<ConstructorElement> generativeConstructorsExposingThis =
       new Set<ConstructorElement>();
 
   /// Data computed internally within elements, like the type-mask of a send a
   /// list allocation, or a for-in loop.
   final Map<MemberElement, GlobalTypeInferenceElementData> _memberData =
       new Map<MemberElement, GlobalTypeInferenceElementData>();
 
-  InferrerEngine(this.compiler, ClosedWorld closedWorld,
+  InferrerEngineImpl(this.compiler, ClosedWorld closedWorld,
       this.closedWorldRefiner, this.mainElement)
       : this.types = new TypeSystem<ast.Node>(
             closedWorld, const TypeSystemStrategyImpl()),
         this.closedWorld = closedWorld;
 
-  CommonElements get commonElements => closedWorld.commonElements;
-
-  /**
-   * Applies [f] to all elements in the universe that match
-   * [selector] and [mask]. If [f] returns false, aborts the iteration.
-   */
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(Element element)) {
     Iterable<MemberEntity> elements = closedWorld.locateMembers(selector, mask);
     for (MemberElement e in elements) {
       if (!f(e.implementation)) return;
     }
   }
 
   // TODO(johnniwinther): Make this private again.
   GlobalTypeInferenceElementData dataOfMember(MemberElement element) =>
@@ skipping 31 matching lines @@
       }
     } else if (callee.isGetter && !selector.isGetter) {
       sideEffects.setAllSideEffects();
       sideEffects.setDependsOnSomething();
     } else {
       MethodElement method = callee.declaration;
       sideEffects.add(closedWorldRefiner.getCurrentlyKnownSideEffects(method));
     }
   }
 
-  /**
-   * Returns the type for [nativeBehavior]. See documentation on
-   * [native.NativeBehavior].
-   */
   TypeInformation typeOfNativeBehavior(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return types.dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
     if (typesReturned.isEmpty) return types.dynamicType;
     TypeInformation returnType;
     for (var type in typesReturned) {
       TypeInformation mappedType;
       if (type == native.SpecialType.JsObject) {
         mappedType = types.nonNullExact(commonElements.objectClass);
       } else if (type == commonElements.stringType) {
@@ skipping 58 matching lines @@
     return generativeConstructorsExposingThis.contains(element);
   }
 
   void recordExposesThis(ConstructorElement element, bool exposesThis) {
     element = element.implementation;
     if (exposesThis) {
       generativeConstructorsExposingThis.add(element);
     }
   }
 
-  JavaScriptBackend get backend => compiler.backend;
-  OptimizerHintsForTests get optimizerHints => backend.optimizerHints;
-  DiagnosticReporter get reporter => compiler.reporter;
-  CommonMasks get commonMasks => closedWorld.commonMasks;
-
-  /**
-   * A set of selector names that [List] implements, that we know return
-   * their element type.
-   */
-  final Set<Selector> returnsListElementTypeSet =
-      new Set<Selector>.from(<Selector>[
-    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)
-  ]);
-
   bool returnsListElementType(Selector selector, TypeMask mask) {
     return mask != null &&
         mask.isContainer &&
         returnsListElementTypeSet.contains(selector);
   }
 
   bool returnsMapValueType(Selector selector, TypeMask mask) {
     return mask != null && mask.isMap && selector.isIndex;
   }
 
@@ skipping 365 matching lines @@
     }
   }
 
   void buildWorkQueue() {
     workQueue.addAll(types.orderedTypeInformations);
     workQueue.addAll(types.allocatedTypes);
     workQueue.addAll(types.allocatedClosures);
     workQueue.addAll(types.allocatedCalls);
   }
 
-  /**
-   * Update the assignments to parameters in the graph. [remove] tells
-   * wheter assignments must be added or removed. If [init] is false,
-   * parameters are added to the work queue.
-   */
   void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true}) {
     if (callee.name == Identifiers.noSuchMethod_) return;
     if (callee.isField) {
       if (selector.isSetter) {
         ElementTypeInformation info = types.getInferredTypeOfMember(callee);
         if (remove) {
           info.removeAssignment(arguments.positional[0]);
         } else {
@@ skipping 54 matching lines @@
           info.removeAssignment(type);
         } else {
           info.addAssignment(type);
         }
         parameterIndex++;
         if (addToQueue) workQueue.add(info);
       });
     }
   }
 
-  /**
-   * Sets the type of a parameter's default value to [type]. If the global
-   * mapping in [defaultTypeOfParameter] already contains a type, it must be
-   * a [PlaceholderTypeInformation], which will be replaced. All its uses are
-   * updated.
-   */
   void setDefaultTypeOfParameter(
       ParameterElement parameter, TypeInformation type) {
     assert(parameter.functionDeclaration.isImplementation);
     TypeInformation existing = defaultTypeOfParameter[parameter];
     defaultTypeOfParameter[parameter] = type;
     TypeInformation info = types.getInferredTypeOfParameter(parameter);
     if (existing != null && existing is PlaceholderTypeInformation) {
       // Replace references to [existing] to use [type] instead.
       if (parameter.functionDeclaration.isInstanceMember) {
         ParameterAssignments assignments = info.assignments;
         assignments.replace(existing, type);
       } else {
         List<TypeInformation> assignments = info.assignments;
         for (int i = 0; i < assignments.length; i++) {
           if (assignments[i] == existing) {
             assignments[i] = type;
           }
         }
       }
       // Also forward all users.
       type.addUsersOf(existing);
     } else {
       assert(existing == null);
     }
   }
 
-  /**
-   * Returns the [TypeInformation] node for the default value of a parameter.
-   * If this is queried before it is set by [setDefaultTypeOfParameter], a
-   * [PlaceholderTypeInformation] is returned, which will later be replaced
-   * by the actual node when [setDefaultTypeOfParameter] is called.
-   *
-   * Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
-   *            should be present and a default type for each parameter should
-   *            exist.
-   */
   TypeInformation getDefaultTypeOfParameter(ParameterElement parameter) {
     return defaultTypeOfParameter.putIfAbsent(parameter, () {
       return new PlaceholderTypeInformation(types.currentMember);
     });
   }
 
-  /**
-   * This helper breaks abstractions but is currently required to work around
-   * the wrong modeling of default values of optional parameters of
-   * synthetic constructors.
-   *
-   * TODO(johnniwinther): Remove once default values of synthetic parameters
-   * are fixed.
-   */
   bool hasAlreadyComputedTypeOfParameterDefault(ParameterElement parameter) {
     TypeInformation seen = defaultTypeOfParameter[parameter];
     return (seen != null && seen is! PlaceholderTypeInformation);
   }
 
-  /**
-   * Returns the type of [element].
-   */
   TypeInformation typeOfParameter(ParameterElement element) {
     return types.getInferredTypeOfParameter(element);
   }
 
-  /**
-   * Returns the type of [element].
-   */
   TypeInformation typeOfMember(MemberElement element) {
     if (element is MethodElement) return types.functionType;
     return types.getInferredTypeOfMember(element);
   }
 
-  /**
-   * Returns the return type of [element].
-   */
   TypeInformation returnTypeOfMember(MemberElement element) {
     if (element is! MethodElement) return types.dynamicType;
     return types.getInferredTypeOfMember(element);
   }
 
-  /**
-   * Records that [node] sets final field [element] to be of type [type].
-   *
-   * [nodeHolder] is the element holder of [node].
-   */
   void recordTypeOfFinalField(FieldElement element, TypeInformation type) {
     types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
-  /**
-   * Records that [node] sets non-final field [element] to be of type
-   * [type].
-   */
   void recordTypeOfNonFinalField(FieldElement element, TypeInformation type) {
     types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
-  /**
-   * Records that [element] is of type [type].
-   */
-  // TODO(johnniwinther): Merge [recordTypeOfFinalField] and
-  // [recordTypeOfNonFinalField] with this?
   void recordTypeOfField(FieldElement element, TypeInformation type) {
     types.getInferredTypeOfMember(element).addAssignment(type);
   }
 
-  /**
-   * Records that the return type [element] is of type [type].
-   */
   void recordReturnType(MethodElement element, TypeInformation type) {
     TypeInformation info = types.getInferredTypeOfMember(element);
     if (element.name == '==') {
       // Even if x.== doesn't return a bool, 'x == null' evaluates to 'false'.
       info.addAssignment(types.boolType);
     }
     // TODO(ngeoffray): Clean up. We do these checks because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (type == null) return;
     if (info.assignments.isEmpty) info.addAssignment(type);
   }
 
-  /**
-   * Notifies to the inferrer that [analyzedElement] can have return
-   * type [newType]. [currentType] is the type the [ElementGraphBuilder]
-   * currently found.
-   *
-   * Returns the new type for [analyzedElement].
-   */
   TypeInformation addReturnTypeForMethod(
       MethodElement element, TypeInformation unused, TypeInformation newType) {
     TypeInformation type = types.getInferredTypeOfMember(element);
     // TODO(ngeoffray): Clean up. We do this check because
     // [SimpleTypesInferrer] deals with two different inferrers.
     if (element.isGenerativeConstructor) return type;
     type.addAssignment(newType);
     return type;
   }
 
-  /**
-   * Registers that [caller] calls [callee] at location [node], with
-   * [selector], and [arguments]. Note that [selector] is null for
-   * forwarding constructors.
-   *
-   * [sideEffects] will be updated to incorporate [callee]'s side
-   * effects.
-   *
-   * [inLoop] tells whether the call happens in a loop.
-   */
   TypeInformation registerCalledMember(
       Spannable node,
       Selector selector,
       TypeMask mask,
       MemberElement caller,
       MemberElement callee,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     CallSiteTypeInformation info = new StaticCallSiteTypeInformation(
@@ skipping 15 matching lines @@
       if (cls.callType != null) {
         types.allocatedClosures.add(info);
       }
     }
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     updateSideEffects(sideEffects, selector, callee);
     return info;
   }
 
-  /**
-   * Registers that [caller] calls [selector] with [receiverType] as
-   * receiver, and [arguments].
-   *
-   * [sideEffects] will be updated to incorporate the potential
-   * callees' side effects.
-   *
-   * [inLoop] tells whether the call happens in a loop.
-   */
   TypeInformation registerCalledSelector(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberElement caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop,
       bool isConditional) {
@@ skipping 16 matching lines @@
         receiverType,
         arguments,
         inLoop,
         isConditional);
 
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     return info;
   }
 
-  /**
-   * Registers a call to await with an expression of type [argumentType] as
-   * argument.
-   */
   TypeInformation registerAwait(ast.Node node, TypeInformation argument) {
     AwaitTypeInformation info =
         new AwaitTypeInformation<ast.Node>(types.currentMember, node);
     info.addAssignment(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
-  /**
-   * Registers a call to yield with an expression of type [argumentType] as
-   * argument.
-   */
   TypeInformation registerYield(ast.Node node, TypeInformation argument) {
     YieldTypeInformation info =
         new YieldTypeInformation<ast.Node>(types.currentMember, node);
     info.addAssignment(argument);
     types.allocatedTypes.add(info);
     return info;
   }
 
-  /**
-   * Registers that [caller] calls [closure] with [arguments].
-   *
-   * [sideEffects] will be updated to incorporate the potential
-   * callees' side effects.
-   *
-   * [inLoop] tells whether the call happens in a loop.
-   */
   TypeInformation registerCalledClosure(
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation closure,
       MemberElement caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     sideEffects.setDependsOnSomething();
@@ skipping 80 matching lines @@
 
   Iterable<MemberEntity> getCallersOf(MemberElement 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;
   }
 
-  /**
-   * Returns the type of [element] when being called with [selector].
-   */
   TypeInformation typeOfMemberWithSelector(
       MemberElement element, Selector selector) {
-    return _typeOfElementWithSelector(element, selector);
-  }
-
-  /**
-   * Returns the type of [element] when being called with [selector].
-   */
-  TypeInformation _typeOfElementWithSelector(
-      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].
       return returnTypeOfMember(element);
     } else if (selector.isGetter) {
       if (element.isFunction) {
         // [functionType] is null if the inferrer did not run.
         return types.functionType == null
             ? types.dynamicType
             : types.functionType;
       } else if (element.isField) {
         return typeOfMember(element);
       } else if (Elements.isUnresolved(element)) {
         return types.dynamicType;
       } else {
         assert(element.isGetter);
         return returnTypeOfMember(element);
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       return types.dynamicType;
     } else {
       return returnTypeOfMember(element);
     }
   }
-
-  /**
-   * Records that the captured variable [local] is read.
-   */
-  void recordCapturedLocalRead(Local local) {}
-
-  /**
-   * Records that the variable [local] is being updated.
-   */
-  void recordLocalUpdate(Local local, TypeInformation type) {}
 }
 
 class TypeSystemStrategyImpl implements TypeSystemStrategy<ast.Node> {
   const TypeSystemStrategyImpl();
 
   @override
   MemberTypeInformation createMemberTypeInformation(
       covariant MemberElement member) {
     assert(member.isDeclaration, failedAt(member));
     if (member.isField) {
@@ skipping 82 matching lines @@
   @override
   bool checkPhiNode(ast.Node node) {
     return true;
   }
 
   @override
   bool checkClassEntity(covariant ClassElement cls) {
     return cls.isDeclaration;
   }
 }