nus-yam/ex-repair huggingface dataset:
Program: 85269
Project: 85269
Buggy source:
@Override public void addAnnotation(Annotation annotation){
  if (!this.processAnnotation(annotation)) {
    annotation.target=ElementType.TYPE;
    this.annotations.add(annotation);
  }
}

Fixed version (ground truth):
@Override public void addAnnotation(Annotation annotation){
  if (!this.processAnnotation(annotation)) {
    annotation.target=ElementType.TYPE;
    if (this.annotations == null) {
      this.annotations=new ArrayList(2);
    }
    this.annotations.add(annotation);
  }
}
Program: 85270
Project: 85270
Buggy source:
@Override public Annotation getAnnotation(IType type){
  for (  Annotation a : this.annotations) {
    if (a.type.classEquals(type)) {
      return a;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public Annotation getAnnotation(IType type){
  if (this.annotations == null) {
    return null;
  }
  for (  Annotation a : this.annotations) {
    if (a.type.classEquals(type)) {
      return a;
    }
  }
  return null;
}
Program: 85271
Project: 85271
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  if (this.superType != null) {
    if (this.superType.isName("String_Node_Str")) {
      this.superType=null;
    }
 else {
      this.superType=this.superType.resolve(context);
    }
  }
  for (ListIterator<IType> iterator=this.interfaces.listIterator(); iterator.hasNext(); ) {
    IType i1=iterator.next();
    IType i2=i1.resolve(context);
    if (i1 != i2) {
      iterator.set(i2);
    }
  }
  if (this.generics != null) {
    for (    ITypeVariable v : this.generics) {
      v.resolveTypes(markers,context);
    }
  }
  for (  Annotation a : this.annotations) {
    a.resolveTypes(markers,this);
  }
  if (this.body != null) {
    this.body.resolveTypes(markers,this);
    for (    IMethod m : this.body.methods) {
      if (m.isName("String_Node_Str")) {
        return;
      }
    }
  }
  Method constructor=new Method(this);
  constructor.setName("String_Node_Str","String_Node_Str");
  constructor.setType(Type.VOID);
  constructor.setModifiers(Modifiers.PUBLIC | Modifiers.SYNTHETIC);
  this.constructor=constructor;
  if (this.superType != null) {
    MethodMatch match=this.superType.resolveConstructor(Util.EMPTY_VALUES);
    if (match != null) {
      this.superConstructor=match.theMethod;
    }
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  if (this.generics != null) {
    for (    ITypeVariable v : this.generics) {
      v.resolveTypes(markers,context);
    }
  }
  if (this.superType != null) {
    if (this.superType.isName("String_Node_Str")) {
      this.superType=null;
    }
 else {
      this.superType=this.superType.resolve(context);
    }
  }
  for (ListIterator<IType> iterator=this.interfaces.listIterator(); iterator.hasNext(); ) {
    IType i1=iterator.next();
    IType i2=i1.resolve(context);
    if (i1 != i2) {
      iterator.set(i2);
    }
  }
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.resolveTypes(markers,this);
    }
  }
  if (this.body != null) {
    this.body.resolveTypes(markers,this);
    for (    IMethod m : this.body.methods) {
      if (m.isName("String_Node_Str")) {
        return;
      }
    }
  }
  Method constructor=new Method(this);
  constructor.setName("String_Node_Str","String_Node_Str");
  constructor.setType(Type.VOID);
  constructor.setModifiers(Modifiers.PUBLIC | Modifiers.SYNTHETIC);
  this.constructor=constructor;
  if (this.superType != null) {
    MethodMatch match=this.superType.resolveConstructor(Util.EMPTY_VALUES);
    if (match != null) {
      this.superConstructor=match.theMethod;
    }
  }
}
Program: 85272
Project: 85272
Buggy source:
@Override public void foldConstants(){
  for (  Annotation a : this.annotations) {
    a.foldConstants();
  }
  if (this.body != null) {
    this.body.foldConstants();
  }
}

Fixed version (ground truth):
@Override public void foldConstants(){
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.foldConstants();
    }
  }
  if (this.body != null) {
    this.body.foldConstants();
  }
}
Program: 85273
Project: 85273
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  for (  Annotation annotation : this.annotations) {
    buffer.append(prefix);
    annotation.toString(prefix,buffer);
    buffer.append('\n');
  }
  buffer.append(prefix).append(Modifiers.CLASS.toString(this.modifiers));
  buffer.append(Modifiers.CLASS_TYPE.toString(this.modifiers)).append(this.name);
  if (this.generics != null && !this.generics.isEmpty()) {
    buffer.append('[');
    Util.astToString(this.generics,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  if (this.superType == null) {
    buffer.append("String_Node_Str");
  }
 else   if (this.superType != Type.OBJECT) {
    buffer.append("String_Node_Str");
    this.superType.toString("String_Node_Str",buffer);
  }
  if (!this.interfaces.isEmpty()) {
    buffer.append("String_Node_Str");
    Util.astToString(this.interfaces,Formatting.Class.superClassesSeperator,buffer);
  }
  if (this.body != null) {
    buffer.append('\n');
    this.body.toString(prefix,buffer);
  }
 else {
    buffer.append(';');
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.annotations != null) {
    for (    Annotation annotation : this.annotations) {
      buffer.append(prefix);
      annotation.toString(prefix,buffer);
      buffer.append('\n');
    }
  }
  buffer.append(prefix).append(Modifiers.CLASS.toString(this.modifiers));
  buffer.append(Modifiers.CLASS_TYPE.toString(this.modifiers)).append(this.name);
  if (this.generics != null && !this.generics.isEmpty()) {
    buffer.append('[');
    Util.astToString(this.generics,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  if (this.superType == null) {
    buffer.append("String_Node_Str");
  }
 else   if (this.superType != Type.OBJECT) {
    buffer.append("String_Node_Str");
    this.superType.toString("String_Node_Str",buffer);
  }
  if (!this.interfaces.isEmpty()) {
    buffer.append("String_Node_Str");
    Util.astToString(this.interfaces,Formatting.Class.superClassesSeperator,buffer);
  }
  if (this.body != null) {
    buffer.append('\n');
    this.body.toString(prefix,buffer);
  }
 else {
    buffer.append(';');
  }
}
Program: 85274
Project: 85274
Buggy source:
@Override public void addAnnotation(Annotation annotation){
  if (!this.processAnnotation(annotation)) {
    annotation.target=ElementType.FIELD;
    this.annotations.add(annotation);
  }
}

Fixed version (ground truth):
@Override public void addAnnotation(Annotation annotation){
  if (!this.processAnnotation(annotation)) {
    annotation.target=ElementType.FIELD;
    if (this.annotations == null) {
      this.annotations=new ArrayList(2);
    }
    this.annotations.add(annotation);
  }
}
Program: 85275
Project: 85275
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  for (  Annotation a : this.annotations) {
    a.resolveTypes(markers,context);
  }
  this.type=this.type.resolve(context);
  if (!this.type.isResolved()) {
    markers.add(Markers.create(this.type.getPosition(),"String_Node_Str",this.type.toString()));
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.type=this.type.resolve(context);
  if (!this.type.isResolved()) {
    markers.add(Markers.create(this.type.getPosition(),"String_Node_Str",this.type.toString()));
  }
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.resolveTypes(markers,context);
    }
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
}
Program: 85276
Project: 85276
Buggy source:
@Override public void write(ClassWriter writer){
  if ((this.modifiers & Modifiers.LAZY) == Modifiers.LAZY) {
    String desc="String_Node_Str" + this.getDescription();
    String signature=this.type.getSignature();
    if (signature != null) {
      signature="String_Node_Str" + signature;
    }
    MethodWriter mw=new MethodWriter(writer,writer.visitMethod(this.modifiers & Modifiers.METHOD_MODIFIERS,this.name,desc,signature,null));
    for (    Annotation a : this.annotations) {
      a.write(mw);
    }
    mw.visitAnnotation("String_Node_Str",false);
    mw.visitCode();
    this.value.writeExpression(mw);
    mw.visitEnd(this.type);
    return;
  }
  FieldVisitor fv=writer.visitField(this.modifiers & 0xFFFF,this.name,this.getDescription(),this.type.getSignature(),null);
  if ((this.modifiers & Modifiers.SEALED) != 0) {
    fv.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    fv.visitAnnotation("String_Node_Str",true);
  }
  for (  Annotation a : this.annotations) {
    a.write(fv);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer){
  if ((this.modifiers & Modifiers.LAZY) == Modifiers.LAZY) {
    String desc="String_Node_Str" + this.getDescription();
    String signature=this.type.getSignature();
    if (signature != null) {
      signature="String_Node_Str" + signature;
    }
    MethodWriter mw=new MethodWriter(writer,writer.visitMethod(this.modifiers & Modifiers.METHOD_MODIFIERS,this.name,desc,signature,null));
    for (    Annotation a : this.annotations) {
      a.write(mw);
    }
    mw.visitAnnotation("String_Node_Str",false);
    mw.visitCode();
    this.value.writeExpression(mw);
    mw.visitEnd(this.type);
    return;
  }
  FieldVisitor fv=writer.visitField(this.modifiers & 0xFFFF,this.name,this.getDescription(),this.type.getSignature(),null);
  if ((this.modifiers & Modifiers.SEALED) != 0) {
    fv.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    fv.visitAnnotation("String_Node_Str",true);
  }
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.write(fv);
    }
  }
}
Program: 85277
Project: 85277
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  for (  Annotation a : this.annotations) {
    a.toString(prefix,buffer);
    buffer.append(' ');
  }
  this.type.toString("String_Node_Str",buffer);
  if (this.isVarargs()) {
    int len=buffer.length();
    buffer.replace(len - 2,len,"String_Node_Str");
  }
  buffer.append(' ').append(this.name);
  if (this.defaultValue != null) {
    buffer.append(Formatting.Field.keyValueSeperator).append(' ');
    this.defaultValue.toString(prefix,buffer);
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.toString(prefix,buffer);
      buffer.append(' ');
    }
  }
  this.type.toString("String_Node_Str",buffer);
  if (this.isVarargs()) {
    int len=buffer.length();
    buffer.replace(len - 2,len,"String_Node_Str");
  }
  buffer.append(' ').append(this.name);
  if (this.defaultValue != null) {
    buffer.append(Formatting.Field.keyValueSeperator).append(' ');
    this.defaultValue.toString(prefix,buffer);
  }
}
Program: 85278
Project: 85278
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.type=this.type.resolve(context);
  if (!this.type.isResolved()) {
    markers.add(Markers.create(this.type.getPosition(),"String_Node_Str",this.type.toString()));
  }
  for (  Annotation a : this.annotations) {
    a.resolveTypes(markers,context);
  }
  if (this.defaultValue != null) {
    this.defaultValue.resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.type=this.type.resolve(context);
  if (!this.type.isResolved() && markers != null) {
    markers.add(Markers.create(this.type.getPosition(),"String_Node_Str",this.type.toString()));
  }
  if (this.annotations != null) {
    for (    Annotation a : this.annotations) {
      a.resolveTypes(markers,context);
    }
  }
  if (this.defaultValue != null) {
    this.defaultValue.resolveTypes(markers,context);
  }
}
Program: 85279
Project: 85279
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context,boolean isStatic){
  if (isStatic && this.child == null) {
    FieldMatch field=context.resolveField(this.name);
    if (field != null) {
      this.field=field;
      return;
    }
    this.methods=new ArrayList();
    context.getMethodMatches(this.methods,null,this.name,null);
    if (!this.methods.isEmpty()) {
      Collections.sort(this.methods);
      return;
    }
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
    return;
  }
  Package pack=context.resolvePackage(this.name);
  if (pack != null) {
    this.thePackage=pack;
    if (this.child != null) {
      this.child.resolveTypes(markers,pack,isStatic);
    }
    return;
  }
  IClass iclass=context.resolveClass(this.name);
  if (iclass != null) {
    this.theClass=iclass;
    if (this.child != null) {
      this.child.resolveTypes(markers,iclass,isStatic);
    }
    return;
  }
  markers.add(Markers.create(this.position,"String_Node_Str",this.name));
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context,boolean isStatic){
  if (isStatic && this.child == null) {
    if (!(context instanceof IClass)) {
      markers.add(Markers.create(this.position,"String_Node_Str"));
      return;
    }
    FieldMatch field=context.resolveField(this.name);
    if (field != null) {
      this.field=field;
      return;
    }
    this.methods=new ArrayList();
    context.getMethodMatches(this.methods,null,this.name,null);
    if (!this.methods.isEmpty()) {
      Collections.sort(this.methods);
      return;
    }
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
    return;
  }
  Package pack=context.resolvePackage(this.name);
  if (pack != null) {
    this.thePackage=pack;
    if (this.child != null) {
      this.child.resolveTypes(markers,pack,isStatic);
    }
    return;
  }
  IClass iclass=context.resolveClass(this.name);
  if (iclass != null) {
    this.theClass=iclass;
    if (this.child != null) {
      this.child.resolveTypes(markers,iclass,isStatic);
    }
    return;
  }
  markers.add(Markers.create(this.position,"String_Node_Str",this.name));
}
Program: 85280
Project: 85280
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type1.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(type1)) {
    return 2;
  }
  return 0;
}
Program: 85281
Project: 85281
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (this.type.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(this.type)) {
    return 2;
  }
  return 0;
}
Program: 85282
Project: 85282
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  int i=this.instance.getValueType();
  if (i == FIELD_ACCESS) {
    FieldAccess access=(FieldAccess)this.instance;
    IField f=access.field;
    if (this.writeIINC(writer,f)) {
      return;
    }
    IValue instance=access.instance;
    if (instance != null) {
      instance.writeExpression(writer);
      writer.visitInsn(Opcodes.DUP);
    }
    f.writeGet(writer);
    this.method.writeCall(writer,null,this.arguments);
    f.writeSet(writer);
  }
 else   if (i == APPLY_METHOD_CALL) {
    ApplyMethodCall call=(ApplyMethodCall)this.instance;
    call.instance.writeExpression(writer);
    for (    IValue v : call.arguments) {
      v.writeExpression(writer);
    }
    writer.visitInsn(Opcodes.DUP2);
    call.method.writeCall(writer,null,Util.EMPTY_VALUES);
    this.method.writeCall(writer,null,this.arguments);
    this.updateMethod.writeCall(writer,null,Util.EMPTY_VALUES);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  int i=this.instance.getValueType();
  if (i == FIELD_ACCESS) {
    FieldAccess access=(FieldAccess)this.instance;
    IField f=access.field;
    if (this.writeIINC(writer,f)) {
      return;
    }
    IValue instance=access.instance;
    if (instance != null) {
      instance.writeExpression(writer);
      writer.visitInsn(Opcodes.DUP);
    }
    f.writeGet(writer,null);
    this.method.writeCall(writer,null,this.arguments);
    f.writeSet(writer,null,null);
  }
 else   if (i == APPLY_METHOD_CALL) {
    ApplyMethodCall call=(ApplyMethodCall)this.instance;
    call.instance.writeExpression(writer);
    for (    IValue v : call.arguments) {
      v.writeExpression(writer);
    }
    writer.visitInsn(Opcodes.DUP2);
    call.method.writeCall(writer,null,Util.EMPTY_VALUES);
    this.method.writeCall(writer,null,this.arguments);
    this.updateMethod.writeCall(writer,null,Util.EMPTY_VALUES);
  }
}
Program: 85283
Project: 85283
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  int i=this.instance.getValueType();
  if (i == FIELD_ACCESS) {
    FieldAccess access=(FieldAccess)this.instance;
    IField f=access.field;
    if (this.writeIINC(writer,f)) {
      return;
    }
    IValue instance=access.instance;
    if (instance != null) {
      instance.writeExpression(writer);
      writer.visitInsn(Opcodes.DUP);
    }
    f.writeGet(writer);
    this.method.writeCall(writer,null,this.arguments);
    writer.visitInsn(Opcodes.DUP);
    f.writeSet(writer);
  }
 else   if (i == APPLY_METHOD_CALL) {
    ApplyMethodCall call=(ApplyMethodCall)this.instance;
    call.instance.writeExpression(writer);
    for (    IValue v : call.arguments) {
      v.writeExpression(writer);
    }
    writer.visitInsn(Opcodes.DUP2);
    call.method.writeCall(writer,null,Util.EMPTY_VALUES);
    this.method.writeCall(writer,null,this.arguments);
    writer.visitInsn(Opcodes.DUP_X2);
    this.updateMethod.writeCall(writer,null,Util.EMPTY_VALUES);
  }
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  int i=this.instance.getValueType();
  if (i == FIELD_ACCESS) {
    FieldAccess access=(FieldAccess)this.instance;
    IField f=access.field;
    if (this.writeIINC(writer,f)) {
      return;
    }
    IValue instance=access.instance;
    if (instance != null) {
      instance.writeExpression(writer);
      writer.visitInsn(Opcodes.DUP);
    }
    f.writeGet(writer,null);
    this.method.writeCall(writer,null,this.arguments);
    writer.visitInsn(Opcodes.DUP);
    f.writeSet(writer,null,null);
  }
 else   if (i == APPLY_METHOD_CALL) {
    ApplyMethodCall call=(ApplyMethodCall)this.instance;
    call.instance.writeExpression(writer);
    for (    IValue v : call.arguments) {
      v.writeExpression(writer);
    }
    writer.visitInsn(Opcodes.DUP2);
    call.method.writeCall(writer,null,Util.EMPTY_VALUES);
    this.method.writeCall(writer,null,this.arguments);
    writer.visitInsn(Opcodes.DUP_X2);
    this.updateMethod.writeCall(writer,null,Util.EMPTY_VALUES);
  }
}
Program: 85284
Project: 85284
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type1.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(type1)) {
    return 2;
  }
  return 0;
}
Program: 85285
Project: 85285
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (this.type.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(this.type)) {
    return 2;
  }
  return 0;
}
Program: 85286
Project: 85286
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  IClass iclass=this.type.getTheClass();
  if (iclass != null) {
    IField field=iclass.getInstanceField();
    if (field != null) {
      field.writeGet(writer);
    }
  }
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  IClass iclass=this.type.getTheClass();
  if (iclass != null) {
    IField field=iclass.getInstanceField();
    if (field != null) {
      field.writeGet(writer,null);
    }
  }
}
Program: 85287
Project: 85287
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (this.type.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(this.type)) {
    return 2;
  }
  return 0;
}
Program: 85288
Project: 85288
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.instance != null) {
    this.instance.writeExpression(writer);
  }
  this.field.writeGet(writer);
  writer.visitInsn(this.field.getType().getReturnOpcode());
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  this.field.writeGet(writer,this.instance);
  writer.visitInsn(this.field.getType().getReturnOpcode());
}
Program: 85289
Project: 85289
Buggy source:
@Override public boolean resolve(IContext context,List<Marker> markers){
  IField field=IAccess.resolveField(context,this.instance,this.qualifiedName);
  if (field != null) {
    if (field.isEnumConstant()) {
      EnumValue enumValue=new EnumValue(this.position);
      enumValue.name=this.name;
      enumValue.qualifiedName=this.qualifiedName;
      enumValue.type=field.getType();
      this.replacement=enumValue;
      return false;
    }
    this.field=field;
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean resolve(IContext context,List<Marker> markers){
  IField field=IAccess.resolveField(context,this.instance,this.qualifiedName);
  if (field != null) {
    if (field.isEnumConstant()) {
      EnumValue enumValue=new EnumValue(this.position);
      enumValue.name=this.name;
      enumValue.qualifiedName=this.qualifiedName;
      enumValue.type=field.getType();
      this.replacement=enumValue;
      return false;
    }
    if (this.instance != null && !(field instanceof Field)) {
      return false;
    }
    this.field=field;
    return true;
  }
  return false;
}
Program: 85290
Project: 85290
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  if (this.instance != null) {
    this.instance.writeExpression(writer);
  }
  this.field.writeGet(writer);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  this.field.writeGet(writer,this.instance);
}
Program: 85291
Project: 85291
Buggy source:
@Override public boolean isResolved(){
  return this.field != null;
}

Fixed version (ground truth):
@Override public boolean isResolved(){
  if (this.field == null) {
    return false;
  }
  if (this.instance != null && !(this.field instanceof Field)) {
    return false;
  }
  return true;
}
Program: 85292
Project: 85292
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.field == null) {
    return 0;
  }
  IType type1=this.field.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type1.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.field == null) {
    return 0;
  }
  IType type1=this.field.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (Type.isSuperType(type,type1)) {
    return 2;
  }
  return 0;
}
Program: 85293
Project: 85293
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.value == null) {
    return;
  }
  if (this.instance != null) {
    this.instance.writeExpression(writer);
  }
  this.value.writeExpression(writer);
  this.field.writeSet(writer);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.value == null) {
    return;
  }
  this.field.writeSet(writer,this.instance,this.value);
}
Program: 85294
Project: 85294
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  if (this.value == null) {
    return;
  }
  if (this.instance != null) {
    this.instance.writeExpression(writer);
  }
  this.value.writeExpression(writer);
  writer.visitInsn(Opcodes.DUP);
  this.field.writeSet(writer);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  if (this.value == null) {
    return;
  }
  if (this.instance != null) {
    this.instance.writeExpression(writer);
  }
  this.value.writeExpression(writer);
  writer.visitInsn(Opcodes.DUP);
  this.field.writeSet(writer,null,null);
}
Program: 85295
Project: 85295
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  this.variable.writeSet(writer);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  this.variable.writeSet(writer,null,this.variable.value);
}
Program: 85296
Project: 85296
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.variable.type.equals(type)) {
    return 3;
  }
 else   if (this.variable.type.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.variable.type.equals(type)) {
    return 3;
  }
 else   if (this.variable.type.isSuperTypeOf(type)) {
    return 2;
  }
  return 0;
}
Program: 85297
Project: 85297
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  writer.visitInsn(Opcodes.DUP);
  this.variable.writeSet(writer);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  writer.visitInsn(Opcodes.DUP);
  this.variable.writeSet(writer,null,null);
}
Program: 85298
Project: 85298
Buggy source:
@Override public IAccess resolve3(IContext context,IAccess next){
  return null;
}

Fixed version (ground truth):
@Override public IAccess resolve3(IContext context,IAccess next){
  List<IValue> list=new ArrayList(this.arguments);
  list.add(next);
  IMethod method=IAccess.resolveMethod(context,this.instance,this.qualifiedName,list);
  if (method != null) {
    this.arguments=list;
    this.method=method;
    return this;
  }
  return null;
}
Program: 85299
Project: 85299
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type1.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (Type.isSuperType(type,type1)) {
    return 2;
  }
  return 0;
}
Program: 85300
Project: 85300
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (this.type.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.type.equals(type)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(this.type)) {
    return 2;
  }
  return 0;
}
Program: 85301
Project: 85301
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type1.isSuperType(type)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.method == null) {
    return 0;
  }
  IType type1=this.method.getType();
  if (type.equals(type1)) {
    return 3;
  }
 else   if (type.isSuperTypeOf(type1)) {
    return 2;
  }
  return 0;
}
Program: 85302
Project: 85302
Buggy source:
@Override public FieldMatch resolveField(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  return super.resolveField(name);
}

Fixed version (ground truth):
@Override public FieldMatch resolveField(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  IField field=this.body.getProperty(name);
  if (field != null) {
    return new FieldMatch(field,1);
  }
  field=this.body.getField(name);
  if (field != null) {
    return new FieldMatch(field,1);
  }
  if (this.instanceField != null && "String_Node_Str".equals(name)) {
    return new FieldMatch(this.instanceField,1);
  }
  FieldMatch match;
  if (this.superType != null && this != Type.PREDEF_CLASS) {
    match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}
Program: 85303
Project: 85303
Buggy source:
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,String name,List<IValue> arguments){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  super.getMethodMatches(list,instance,name,arguments);
}

Fixed version (ground truth):
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,String name,List<IValue> arguments){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  this.body.getMethodMatches(list,instance,name,arguments);
  if (!list.isEmpty()) {
    return;
  }
  if (this.superType != null) {
    this.superType.getMethodMatches(list,instance,name,arguments);
  }
  for (  IType i : this.interfaces) {
    i.getMethodMatches(list,instance,name,arguments);
  }
}
Program: 85304
Project: 85304
Buggy source:
@Override public void getConstructorMatches(List<MethodMatch> list,List<IValue> arguments){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  super.getConstructorMatches(list,arguments);
}

Fixed version (ground truth):
@Override public void getConstructorMatches(List<MethodMatch> list,List<IValue> arguments){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  this.body.getMethodMatches(list,null,"String_Node_Str",arguments);
}
Program: 85305
Project: 85305
Buggy source:
@Override public boolean equals(IClass iclass){
  if (!iclass.isSuperType(this.superType)) {
    return false;
  }
  for (  IType i : this.interfaces) {
    if (!iclass.isSuperType(i)) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean equals(IClass iclass){
  if (!iclass.isSubTypeOf(this.superType)) {
    return false;
  }
  for (  IType i : this.interfaces) {
    if (!iclass.isSubTypeOf(i)) {
      return false;
    }
  }
  return true;
}
Program: 85306
Project: 85306
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest){
  this.left.writeExpression(writer);
  writer.visitJumpInsn(Opcodes.IFEQ,dest);
  this.right.writeExpression(writer);
  writer.visitJumpInsn(Opcodes.IFEQ,dest);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest){
  this.left.writeExpression(writer);
  writer.visitJumpInsn2(Opcodes.IFEQ,dest);
  this.right.writeExpression(writer);
  writer.visitJumpInsn2(Opcodes.IFEQ,dest);
}
Program: 85307
Project: 85307
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.then == null) {
    this.condition.writeStatement(writer);
  }
  writer.visitLabel(this.start);
  this.condition.writeJump(writer,this.end);
  this.then.writeStatement(writer);
  writer.visitJumpInsn(Opcodes.GOTO,this.start);
  writer.visitLabel(this.end);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.then == null) {
    this.condition.writeStatement(writer);
  }
  writer.visitLabel(this.start);
  this.condition.writeJump(writer,this.end);
  this.then.writeStatement(writer);
  writer.visitJumpInsn(Opcodes.GOTO,this.start);
  writer.visitLabel(this.end);
  writer.visitInsn(Opcodes.NOP);
}
Program: 85308
Project: 85308
Buggy source:
private void processInsn(int opcode){
switch (opcode) {
case DUP:
    this.typeStack.push(this.typeStack.peek());
  return;
case SWAP:
{
  Object o1=this.typeStack.pop();
  Object o2=this.typeStack.pop();
  this.typeStack.push(o1);
  this.typeStack.push(o2);
  return;
}
case POP:
this.typeStack.pop();
return;
case ACONST_NULL:
this.push(NULL);
return;
case ARRAYLENGTH:
this.set(INTEGER);
return;
case RETURN:
this.hasReturn=true;
return;
case IADD:
case ISUB:
case IMUL:
case IDIV:
case IREM:
case ISHL:
case ISHR:
case IUSHR:
this.typeStack.pop();
this.typeStack.pop();
this.push(INTEGER);
return;
case LADD:
case LSUB:
case LMUL:
case LDIV:
case LREM:
case LSHL:
case LSHR:
case LUSHR:
this.typeStack.pop();
this.typeStack.pop();
this.push(LONG);
return;
case FADD:
case FSUB:
case FMUL:
case FDIV:
case FREM:
this.typeStack.pop();
this.typeStack.pop();
this.push(FLOAT);
return;
case DADD:
case DSUB:
case DMUL:
case DDIV:
case DREM:
this.typeStack.pop();
this.typeStack.pop();
this.push(DOUBLE);
return;
case L2I:
case F2I:
case D2I:
this.set(INTEGER);
case I2L:
case F2L:
case D2L:
this.set(LONG);
return;
case I2F:
case L2F:
case D2F:
this.set(FLOAT);
return;
case LCMP:
case FCMPL:
case FCMPG:
case DCMPL:
case DCMPG:
this.typeStack.pop();
this.typeStack.pop();
this.push(INTEGER);
return;
}
}

Fixed version (ground truth):
private void processInsn(int opcode){
switch (opcode) {
case DUP:
    this.typeStack.push(this.typeStack.peek());
  return;
case SWAP:
{
  Object o1=this.typeStack.pop();
  Object o2=this.typeStack.pop();
  this.typeStack.push(o1);
  this.typeStack.push(o2);
  return;
}
case POP:
this.typeStack.pop();
return;
case ACONST_NULL:
this.push(NULL);
return;
case ARRAYLENGTH:
this.set(INTEGER);
return;
case RETURN:
this.hasReturn=true;
return;
case BALOAD:
case SALOAD:
case CALOAD:
case IALOAD:
this.typeStack.pop();
this.typeStack.pop();
this.push(INTEGER);
break;
case LALOAD:
this.typeStack.pop();
this.typeStack.pop();
this.push(LONG);
break;
case FALOAD:
this.typeStack.pop();
this.typeStack.pop();
this.push(FLOAT);
break;
case DALOAD:
this.typeStack.pop();
this.typeStack.pop();
this.push(DOUBLE);
break;
case AALOAD:
this.typeStack.pop();
this.typeStack.pop();
this.push(TOP);
case IADD:
case ISUB:
case IMUL:
case IDIV:
case IREM:
case ISHL:
case ISHR:
case IUSHR:
this.typeStack.pop();
this.typeStack.pop();
this.push(INTEGER);
return;
case LADD:
case LSUB:
case LMUL:
case LDIV:
case LREM:
case LSHL:
case LSHR:
case LUSHR:
this.typeStack.pop();
this.typeStack.pop();
this.push(LONG);
return;
case FADD:
case FSUB:
case FMUL:
case FDIV:
case FREM:
this.typeStack.pop();
this.typeStack.pop();
this.push(FLOAT);
return;
case DADD:
case DSUB:
case DMUL:
case DDIV:
case DREM:
this.typeStack.pop();
this.typeStack.pop();
this.push(DOUBLE);
return;
case L2I:
case F2I:
case D2I:
this.set(INTEGER);
case I2L:
case F2L:
case D2L:
this.set(LONG);
return;
case I2F:
case L2F:
case D2F:
this.set(FLOAT);
return;
case LCMP:
case FCMPL:
case FCMPG:
case DCMPL:
case DCMPG:
this.typeStack.pop();
this.typeStack.pop();
this.push(INTEGER);
return;
}
}
Program: 85309
Project: 85309
Buggy source:
@Override public void visitInsn(int opcode){
  if (opcode > 255) {
    this.visitSpecialInsn(opcode);
    return;
  }
  if (opcode >= IALOAD && opcode <= SALOAD) {
    Object o=this.typeStack.pop();
    this.typeStack.pop();
    if (o instanceof String) {
      this.push(((String)o).substring(1));
    }
 else {
      this.push(TOP);
    }
  }
 else   if (opcode >= IASTORE && opcode <= SASTORE) {
    this.typeStack.pop();
    this.typeStack.pop();
    this.typeStack.pop();
  }
 else   if (opcode >= IRETURN && opcode <= ARETURN) {
    this.typeStack.pop();
  }
 else {
    this.processInsn(opcode);
  }
  this.mv.visitInsn(opcode);
}

Fixed version (ground truth):
@Override public void visitInsn(int opcode){
  if (opcode > 255) {
    this.visitSpecialInsn(opcode);
    return;
  }
 else   if (opcode >= IASTORE && opcode <= SASTORE) {
    this.typeStack.pop();
    this.typeStack.pop();
    this.typeStack.pop();
  }
 else   if (opcode >= IRETURN && opcode <= ARETURN) {
    this.typeStack.pop();
  }
 else {
    this.processInsn(opcode);
  }
  this.mv.visitInsn(opcode);
}
Program: 85310
Project: 85310
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest){
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest){
  this.writeExpression(writer);
  writer.visitJumpInsn(Opcodes.IFEQ,dest);
}
Program: 85314
Project: 85314
Buggy source:
public void addLocal(int index,Object type){
  this.locals.add(type);
}

Fixed version (ground truth):
public void addLocal(int index,Object type){
  this.ensureLocals(index);
  this.locals[index]=type;
}
Program: 85315
Project: 85315
Buggy source:
public void visitParameter(String name,IType type,int index){
  this.locals.add(type.getFrameType());
  this.mv.visitParameter(name,index);
}

Fixed version (ground truth):
public void visitParameter(String name,IType type,int index){
  this.addLocal(index,type.getFrameType());
  this.mv.visitParameter(name,index);
}
Program: 85316
Project: 85316
Buggy source:
private void visitFrame(){
  int len=this.typeStack.size();
  Object[] o=new Object[len];
  for (int i=0; i < len; i++) {
    o[i]=this.typeStack.get(i);
  }
  this.mv.visitFrame(F_NEW,this.locals.size(),this.locals.toArray(),len,o);
}

Fixed version (ground truth):
private void visitFrame(){
  int len=this.typeStack.size();
  Object[] o=new Object[len];
  for (int i=0; i < len; i++) {
    o[i]=this.typeStack.get(i);
  }
  this.mv.visitFrame(F_NEW,this.maxLocals,this.locals,len,o);
}
Program: 85317
Project: 85317
Buggy source:
public void visitEnd(IType type){
  if (!this.hasReturn) {
    this.mv.visitInsn(type.getReturnOpcode());
  }
  this.mv.visitMaxs(this.maxStack,this.locals.size());
  this.mv.visitEnd();
}

Fixed version (ground truth):
public void visitEnd(IType type){
  if (!this.hasReturn) {
    this.mv.visitInsn(type.getReturnOpcode());
  }
  this.mv.visitMaxs(this.maxStack,this.maxLocals);
  this.mv.visitEnd();
}
Program: 85318
Project: 85318
Buggy source:
public void setConstructor(IType type){
  this.locals.add(UNINITIALIZED_THIS);
  this.push(UNINITIALIZED_THIS);
}

Fixed version (ground truth):
public void setConstructor(IType type){
  this.locals[0]=UNINITIALIZED_THIS;
  this.push(UNINITIALIZED_THIS);
}
Program: 85319
Project: 85319
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  this.writeExpression(writer);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  int opcode;
  int args=this.arguments.size();
  if (this.isCustom) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else {
    opcode=Opcodes.INVOKESPECIAL;
    args++;
    writer.visitTypeInsn(Opcodes.NEW,this.type);
  }
  for (  IValue arg : this.arguments) {
    arg.writeExpression(writer);
  }
  String owner=this.method.getTheClass().getInternalName();
  String name="String_Node_Str";
  String desc=this.method.getDescriptor();
  writer.visitMethodInsn(opcode,owner,name,desc,false,args,null);
}
Program: 85320
Project: 85320
Buggy source:
@Override public boolean resolve(IContext context,List<Marker> markers){
  if (!this.type.isResolved()) {
    return false;
  }
  MethodMatch match=this.type.resolveMethod(null,"String_Node_Str",this.arguments);
  if (match != null) {
    this.method=match.theMethod;
    this.isCustom=true;
    return true;
  }
  match=this.type.resolveMethod(null,"String_Node_Str",this.arguments);
  if (match != null) {
    this.method=match.theMethod;
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean resolve(IContext context,List<Marker> markers){
  if (!this.type.isResolved()) {
    return false;
  }
  MethodMatch match=this.type.resolveMethod(null,"String_Node_Str",this.arguments);
  if (match != null) {
    this.method=match.theMethod;
    return true;
  }
  return false;
}
Program: 85321
Project: 85321
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  int opcode;
  int args=this.arguments.size();
  if (this.isCustom) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else {
    opcode=Opcodes.INVOKESPECIAL;
    args++;
    writer.visitTypeInsn(Opcodes.NEW,this.type);
    writer.visitInsn(Opcodes.DUP,this.type);
  }
  for (  IValue arg : this.arguments) {
    arg.writeExpression(writer);
  }
  String owner=this.method.getTheClass().getInternalName();
  String name=this.method.getName();
  String desc=this.method.getDescriptor();
  writer.visitMethodInsn(opcode,owner,name,desc,false,args,null);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  int opcode;
  int args=this.arguments.size();
  if (this.isCustom) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else {
    opcode=Opcodes.INVOKESPECIAL;
    args++;
    writer.visitTypeInsn(Opcodes.NEW,this.type);
    writer.visitInsn(Opcodes.DUP,this.type);
  }
  for (  IValue arg : this.arguments) {
    arg.writeExpression(writer);
  }
  String owner=this.method.getTheClass().getInternalName();
  String name="String_Node_Str";
  String desc=this.method.getDescriptor();
  writer.visitMethodInsn(opcode,owner,name,desc,false,args,null);
}
Program: 85322
Project: 85322
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString("String_Node_Str",buffer);
    if (this.dotless && !Formatting.Method.useJavaFormat) {
      buffer.append(Formatting.Method.dotlessSeperator);
    }
 else {
      buffer.append('.');
    }
  }
  if (Formatting.Method.convertQualifiedNames) {
    buffer.append(this.qualifiedName);
  }
 else {
    buffer.append(this.name);
  }
  if (this.isSugarCall && !Formatting.Method.useJavaFormat) {
    if (!this.arguments.isEmpty()) {
      buffer.append(Formatting.Method.sugarCallSeperator);
      this.arguments.get(0).toString("String_Node_Str",buffer);
    }
  }
 else {
    Util.parametersToString(this.arguments,buffer,true);
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString(prefix,buffer);
    if (this.dotless && !Formatting.Method.useJavaFormat) {
      buffer.append(Formatting.Method.dotlessSeperator);
    }
 else {
      buffer.append('.');
    }
  }
  if (Formatting.Method.convertQualifiedNames) {
    buffer.append(this.qualifiedName);
  }
 else {
    buffer.append(this.name);
  }
  if (this.isSugarCall && !Formatting.Method.useJavaFormat) {
    if (!this.arguments.isEmpty()) {
      buffer.append(Formatting.Method.sugarCallSeperator);
      this.arguments.get(0).toString(prefix,buffer);
    }
  }
 else {
    Util.parametersToString(this.arguments,buffer,true);
  }
}
Program: 85323
Project: 85323
Buggy source:
@Override public void writeSet(MethodWriter writer){
  String owner=this.theClass.getInternalName();
  String name=this.name;
  String desc=this.type.getExtendedName();
  if ((this.modifiers & Modifiers.STATIC) == Modifiers.STATIC) {
    writer.visitPutStatic(owner,name,desc);
  }
 else {
    writer.visitPutStatic(owner,name,desc);
  }
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer){
  String owner=this.theClass.getInternalName();
  String name=this.name;
  String desc=this.type.getExtendedName();
  if ((this.modifiers & Modifiers.STATIC) == Modifiers.STATIC) {
    writer.visitPutStatic(owner,name,desc);
  }
 else {
    writer.visitPutField(owner,name,desc);
  }
}
Program: 85324
Project: 85324
Buggy source:
@Override public String getDescriptor(){
  StringBuilder buf=new StringBuilder();
  buf.append('(');
  for (  Parameter par : this.parameters) {
    buf.append(par.type.getExtendedName());
  }
  buf.append(')');
  buf.append(this.type.getExtendedName());
  return buf.toString();
}

Fixed version (ground truth):
@Override public String getDescriptor(){
  StringBuilder buf=new StringBuilder();
  buf.append('(');
  for (  Parameter par : this.parameters) {
    buf.append(par.type.getExtendedName());
  }
  buf.append(')');
  buf.append(this.isConstructor ? "String_Node_Str" : this.type.getExtendedName());
  return buf.toString();
}
Program: 85325
Project: 85325
Buggy source:
@Override public void write(ClassWriter writer){
  int modifiers=this.modifiers & 0xFFFF;
  if (this.statement == null) {
    modifiers|=Modifiers.ABSTRACT;
  }
  MethodVisitor visitor=writer.visitMethod(modifiers,this.qualifiedName,this.getDescriptor(),this.getSignature(),this.getExceptions());
  MethodWriter mw=new MethodWriter(visitor);
  if (this.isConstructor) {
    mw.setConstructor(this.type);
  }
  for (  Annotation annotation : this.annotations) {
    annotation.write(mw);
  }
  if ((this.modifiers & Modifiers.INLINE) == Modifiers.INLINE) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.IMPLICIT) == Modifiers.IMPLICIT) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.SEALED) == Modifiers.SEALED) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  for (  Parameter param : this.parameters) {
    param.write(mw);
  }
  if (this.statement != null) {
    mw.visitCode();
    this.statement.writeExpression(mw);
    mw.visitEnd(this.isConstructor ? Type.VOID : this.type);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer){
  int modifiers=this.modifiers & 0xFFFF;
  if (this.statement == null) {
    modifiers|=Modifiers.ABSTRACT;
  }
  MethodVisitor visitor=writer.visitMethod(modifiers,this.qualifiedName,this.getDescriptor(),this.getSignature(),this.getExceptions());
  MethodWriter mw=new MethodWriter(visitor);
  if (this.isConstructor) {
    mw.setConstructor(this.type);
  }
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    mw.setInstance(this.type);
  }
  for (  Annotation annotation : this.annotations) {
    annotation.write(mw);
  }
  if ((this.modifiers & Modifiers.INLINE) == Modifiers.INLINE) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.IMPLICIT) == Modifiers.IMPLICIT) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  if ((this.modifiers & Modifiers.SEALED) == Modifiers.SEALED) {
    mw.visitAnnotation("String_Node_Str",false);
  }
  for (  Parameter param : this.parameters) {
    param.write(mw);
  }
  if (this.statement != null) {
    mw.visitCode();
    this.statement.writeExpression(mw);
    mw.visitEnd(this.isConstructor ? Type.VOID : this.type);
  }
}
Program: 85326
Project: 85326
Buggy source:
public Method(IClass iclass,String name,IType type,int modifiers,List<Annotation> annotations){
  super(iclass,name,type,modifiers,annotations);
  if (name.equals("String_Node_Str")) {
    this.isConstructor=true;
  }
}

Fixed version (ground truth):
public Method(IClass iclass,String name,IType type,int modifiers,List<Annotation> annotations){
  super(iclass,name,type,modifiers,annotations);
  if (name.equals("String_Node_Str")) {
    this.isConstructor=true;
    this.qualifiedName="String_Node_Str";
  }
}
Program: 85327
Project: 85327
Buggy source:
@Override public default boolean isStatic(){
  return true;
}

Fixed version (ground truth):
@Override public default boolean isStatic(){
  return false;
}