anchor.diff:    }
   
     void addMemberMethod(FunctionElement member, ClassBuilder builder) {
  -    if (member.isAbstract) return;
  +    MemberInfo info = analyzeMemberMethod(member);
  +    if (info != null) {
  +      addMemberMethodFromInfo(info, builder);
  +    }
  +  }
  +
  +  MemberInfo analyzeMemberMethod(FunctionElement member) {
  +    if (member.isAbstract) return null;
       jsAst.Expression code = backend.generatedCode[member];
  -    if (code == null) return;
  +    if (code == null) return null;
       String name = namer.getNameOfMember(member);
  -    emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
  +
       FunctionSignature parameters = member.functionSignature;
       bool needsStubs = !parameters.optionalParameters.isEmpty;
       bool canTearOff = false;
  
positive.code:     // For now, do nothing.
    }
  }
  
negative.code: 
      final bool needStructuredInfo =
          canTearOff || canBeReflected || canBeApplied;
  
      if (canTearOff) {
        assert(invariant(member, !member.isGenerativeConstructor));
        assert(invariant(member, !member.isGenerativeConstructorBody));
        assert(invariant(member, !member.isConstructor));
      }
  
      return new MemberInfo(
          member,
          name,
          parameters,
          code,
          needsStubs: needsStubs,
          canTearOff: canTearOff,
          isClosure: isClosure,
          tearOffName: tearOffName,
          canBeReflected: canBeReflected,
          canBeApplied: canBeApplied,
          needStructuredInfo: needStructuredInfo);
  
    }
  
    void addMemberMethodFromInfo(MemberInfo info, ClassBuilder builder) {
      final FunctionElement member = info.member;
      final String name = info.name;
      final FunctionSignature parameters = info.parameters;
      jsAst.Expression code = info.code;
      final bool needsStubs = info.needsStubs;
      final bool canTearOff = info.canTearOff;
      final bool isClosure = info.isClosure;
      final String tearOffName = info.tearOffName;
      final bool canBeReflected = info.canBeReflected;
      final bool canBeApplied = info.canBeApplied;
      final bool needStructuredInfo = info.needStructuredInfo;
  
      emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
  
      if (!needStructuredInfo) {
        compiler.dumpInfoTask.registerElementAst(member,
            builder.addProperty(name, code));
  