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:     values.remove(node.variable);
    }
  }
  
negative.code: import '../world.dart' show World;
  import 'cps_fragment.dart';
  import 'cps_ir_nodes.dart';
  import 'cps_ir_nodes_sexpr.dart' show SExpressionStringifier;
  
  enum AbstractBool {
    True, False, Maybe, Nothing
  