anchor.diff:    static final String parseFunctionDescriptorBoilerplate = r"""
   function parseFunctionDescriptor(proto, name, descriptor) {
     if (descriptor instanceof Array) {
  -    proto[name] = descriptor[0];
  -    var funs = [descriptor[0]];
  -    funs[0].$callName = descriptor[1];
  -    for (var pos = 6; pos < descriptor.length; pos += 3) {
  +    // 'pos' points to the last read entry.
  +    var f, pos = -1;
  +    var aliasOrFunction = descriptor[++pos];
  +    if (typeof aliasOrFunction == "string") {
  +      // Install the alias for super calls on the prototype chain.
  +      proto[aliasOrFunction] = f = descriptor[++pos];
  +    } else {
  +      f = aliasOrFunction;
  +    }
  +
  +    proto[name] = f;
  +    var funs = [f];
  +    f.$callName = descriptor[++pos];
  +
  +    var isInterceptedOrParameterStubName = descriptor[pos + 1];
  +    var isIntercepted, tearOffName, reflectionInfo;
  +    if (typeof isInterceptedOrParameterStubName == "boolean") {
  +      isIntercepted = descriptor[++pos];
  +      tearOffName = descriptor[++pos];
  +      reflectionInfo = descriptor[++pos];
  +    }
  +
  +    for (++pos; pos < descriptor.length; pos += 3) {
         var stub = descriptor[pos + 2];
         stub.$callName = descriptor[pos + 1];
         proto[descriptor[pos]] = stub;
         funs.push(stub);
       }
  -    if (descriptor[2] != null) {
  -      var isIntercepted = descriptor[3];
  -      var reflectionInfo = descriptor[4];
  -      proto[descriptor[2]] = 
  +
  +    if (tearOffName) {
  +      proto[tearOffName] =
             tearOff(funs, reflectionInfo, false, name, isIntercepted);
       }
  -    // Install the alias for super calls on the prototype chain.
  -    if (descriptor[5] != null) {
  -      proto[descriptor[5]] = descriptor[0];
  -    }
  +
     } else {
       proto[name] = descriptor;
     }
  
positive.code:   /// facilitate the generation of tearOffs at runtime. The format is an array
    /// with the following fields:
    ///
    /// [Method.code]
    /// [DartMethod.callName]
    /// [DartMethod.tearOffName]
    /// [JavaScriptBackend.isInterceptedMethod]
    /// functionType
    /// [InstanceMethod.aliasName]
    ///
    /// followed by
    ///
  
negative.code:       if (method.needsTearOff || method.aliasName != null) {
          /// See [parseFunctionDescriptorBoilerplate] for a full description of
          /// the format.
          // [name, [aliasName, function, callName, isIntercepted, tearOffName,
          // functionType, stub1_name, stub1_callName, stub1_code, ...]
          var data = [];
          if (method.aliasName != null) {
            data.add(js.string(method.aliasName));
          }
          data.add(method.code);
          data.add(js.string(method.callName));
  
          if (method.needsTearOff) {
            bool isIntercepted = backend.isInterceptedMethod(method.element);
            data.add(new js.LiteralBool(isIntercepted));
            data.add(js.string(method.tearOffName));
            data.add(_generateFunctionType(method.type));
          }
  
          data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
          return [js.string(method.name), new js.ArrayInitializer(data)];
        } else {
  