anchor.diff:      return false;
     }
   
  -  /// Inlines a single-use closure if it leaves the closure object with only
  -  /// field accesses.  This is optimized later by [ScalarReplacer].
  -  bool specializeSingleUseClosureCall(InvokeMethod node) {
  -    Selector call = node.selector;
  -    if (!call.isClosureCall) return false;
  -
  -    assert(!isInterceptedSelector(call));
  -    assert(call.argumentCount == node.arguments.length);
  -
  -    Primitive receiver = node.receiver.definition;
  -    if (receiver is !CreateInstance) return false;
  -    CreateInstance createInstance = receiver;
  -    if (!createInstance.hasExactlyOneUse) return false;
  -
  -    // Inline only closures. This avoids inlining the 'call' method of a class
  -    // that has many allocation sites.
  -    if (createInstance.classElement is !ClosureClassElement) return false;
  -
  -    ClosureClassElement closureClassElement = createInstance.classElement;
  -    Element element = closureClassElement.localLookup(Identifiers.call);
  -
  -    if (element == null || !element.isFunction) return false;
  -    FunctionElement functionElement = element;
  -    if (functionElement.asyncMarker != AsyncMarker.SYNC) return false;
  -
  -    if (!call.signatureApplies(functionElement)) return false;
  -    // Inline only for exact match.
  -    // TODO(sra): Handle call with defaulted arguments.
  -    Selector targetSelector = new Selector.fromElement(functionElement);
  -    if (call.callStructure != targetSelector.callStructure) return false;
  -
  -    FunctionDefinition target =
  -        functionCompiler.compileToCpsIR(functionElement);
  -
  -    // Accesses to closed-over values are field access primitives.  We we don't
  -    // inline if there are other uses of 'this' since that could be an escape or
  -    // a recursive call.
  -    for (Reference ref = target.thisParameter.firstRef;
  -         ref != null;
  -         ref = ref.next) {
  -      Node use = ref.parent;
  -      if (use is GetField) continue;
  -      // Closures do not currently have writable fields, but closure conversion
  -      // could esily be changed to allocate some cells in a closure object.
  -      if (use is SetField && ref == use.object) continue;
  -      return false;
  -    }
  -
  -    // Don't inline if [target] contains try-catch or try-finally. JavaScript
  -    // engines typically do poor optimization of the entire function containing
  -    // the 'try'.
  -    if (ContainsTry.analyze(target)) return false;
  -
  -    node.receiver.definition.substituteFor(target.thisParameter);
  -    for (int i = 0; i < node.arguments.length; ++i) {
  -      node.arguments[i].definition.substituteFor(target.parameters[i]);
  -    }
  -    node.continuation.definition.substituteFor(target.returnContinuation);
  -
  -    replaceSubtree(node, target.body);
  -    push(target.body);
  -    return true;
  -  }
  -
     /// Side-effect free expressions with constant results are be replaced by:
     ///
     ///    (LetPrim p = constant (InvokeContinuation k p)).
  
positive.code:     if (specializeFieldAccess(node)) return;
      if (specializeIndexableAccess(node)) return;
      if (specializeArrayAccess(node)) return;
      if (specializeSingleUseClosureCall(node)) return;
      if (specializeClosureCall(node)) return;
  
      AbstractValue receiver = getValue(node.receiver.definition);
  
negative.code:     values.remove(node.variable);
    }
  }
  