anchor.diff:      // For now, do nothing.
     }
   }
  +
  +class MemberInfo {
  +  final FunctionElement member;
  +
  +  final String name;
  +
  +  final FunctionSignature parameters;
  +
  +  final jsAst.Expression code;
  +
  +  final bool needsStubs;
  +
  +  final bool canTearOff;
  +
  +  final bool isClosure;
  +
  +  final String tearOffName;
  +
  +  final bool canBeReflected;
  +
  +  final bool canBeApplied;
  +
  +  final bool needStructuredInfo;
  +
  +  MemberInfo(
  +      this.member,
  +      this.name,
  +      this.parameters,
  +      this.code,
  +      {this.needsStubs,
  +       this.canTearOff,
  +       this.isClosure,
  +       this.tearOffName,
  +       this.canBeReflected,
  +       this.canBeApplied,
  +       this.needStructuredInfo}) {
  +    assert(member != null);
  +    assert(name != null);
  +    assert(parameters != null);
  +    assert(code != null);
  +    assert(needsStubs != null);
  +    assert(canTearOff != null);
  +    assert(isClosure != null);
  +    assert(tearOffName != null || !canTearOff);
  +    assert(canBeReflected != null);
  +    assert(canBeApplied != null);
  +    assert(needStructuredInfo != null);
  +  }
  +}
  
positive.code:   }
  
    void addMemberMethod(FunctionElement member, ClassBuilder builder) {
      if (member.isAbstract) return;
      jsAst.Expression code = backend.generatedCode[member];
      if (code == null) return;
      String name = namer.getNameOfMember(member);
      emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
      FunctionSignature parameters = member.functionSignature;
      bool needsStubs = !parameters.optionalParameters.isEmpty;
      bool canTearOff = false;
  
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));
  