nus-yam/ex-repair huggingface dataset:
Program: 85225
Project: 85225
Buggy source:
public boolean equals(IType type){
  if (this.arrayDimensions != type.getArrayDimensions()) {
    return false;
  }
  return this.classEquals(type);
}

Fixed version (ground truth):
@Override public boolean equals(IType type){
  if (this.arrayDimensions != type.getArrayDimensions()) {
    return false;
  }
  return this.theClass == type.getTheClass();
}
Program: 85226
Project: 85226
Buggy source:
public default void addTypeVariables(IType type,Map<String,IType> typeVariables){
  IType t=this.getType();
  type.addTypeVariables(t,typeVariables);
}

Fixed version (ground truth):
public default void addTypeVariables(IType type,Map<String,IType> typeVariables){
  IType t=this.getType();
  if (type.equals(t)) {
    type.addTypeVariables(t,typeVariables);
  }
}
Program: 85227
Project: 85227
Buggy source:
@Override public void check(List<Marker> markers,IContext context){
  if (this.value.getValueType() == IValue.THIS) {
    markers.add(new SyntaxError(this.position,"String_Node_Str"));
  }
  if (this.field == null) {
    return;
  }
  IType type=this.field.getType();
  IValue value1=this.value.withType(type);
  if (value1 == null) {
    Marker marker=Markers.create(this.value.getPosition(),"String_Node_Str",this.name);
    marker.addInfo("String_Node_Str" + type);
    IType vtype=this.value.getType();
    marker.addInfo("String_Node_Str" + (vtype == null ? "String_Node_Str" : vtype));
    markers.add(marker);
  }
 else {
    this.value=value1;
  }
  if (this.field.hasModifier(Modifiers.FINAL)) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
  if (this.field.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
  byte access=context.getAccessibility(this.field);
  if (access == IContext.STATIC) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
 else   if (access == IContext.SEALED) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
 else   if ((access & IContext.WRITE_ACCESS) == 0) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
}

Fixed version (ground truth):
@Override public void check(List<Marker> markers,IContext context){
  if (this.value.getValueType() == IValue.THIS) {
    markers.add(new SyntaxError(this.position,"String_Node_Str"));
  }
  if (this.field == null) {
    return;
  }
  IType type=this.field.getType();
  IValue value1=this.value.withType(type);
  if (value1 == null) {
    Marker marker=Markers.create(this.value.getPosition(),"String_Node_Str",this.name);
    marker.addInfo("String_Node_Str" + type);
    IType vtype=this.value.getType();
    marker.addInfo("String_Node_Str" + (vtype == null ? "String_Node_Str" : vtype));
    markers.add(marker);
  }
 else {
    this.value=value1;
  }
  value1.check(markers,context);
  if (this.field.hasModifier(Modifiers.FINAL)) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
  if (this.field.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
  byte access=context.getAccessibility(this.field);
  if (access == IContext.STATIC) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
 else   if (access == IContext.SEALED) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
 else   if ((access & IContext.WRITE_ACCESS) == 0) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
}
Program: 85228
Project: 85228
Buggy source:
@Override public IType getConcreteType(Map<String,IType> typeVariables){
  if (this.name != null) {
    IType t=typeVariables.get(this.name);
    if (t != null) {
      if (this.arrayDimensions > 0) {
        return t.getArrayType(this.arrayDimensions);
      }
      return t;
    }
  }
  WildcardType type=new WildcardType(this.position);
  if (this.lowerBound != null) {
    type.lowerBound=this.lowerBound.getConcreteType(typeVariables);
  }
  if (this.upperBound != null) {
    type.upperBound=this.upperBound.getConcreteType(typeVariables);
  }
  if (this.upperBounds != null) {
    int len=this.upperBounds.size();
    if (len > 0) {
      type.upperBounds=new ArrayList(len);
      for (int i=0; i < len; i++) {
        type.upperBounds.add(this.upperBounds.get(i).getConcreteType(typeVariables));
      }
    }
  }
  return type;
}

Fixed version (ground truth):
@Override public IType getConcreteType(Map<String,IType> typeVariables){
  if (this.name != null) {
    IType t=typeVariables.get(this.name);
    if (t != null) {
      if (this.arrayDimensions > 0) {
        return t.getArrayType(this.arrayDimensions);
      }
      return t;
    }
    return this;
  }
  WildcardType type=new WildcardType(this.position);
  if (this.lowerBound != null) {
    type.lowerBound=this.lowerBound.getConcreteType(typeVariables);
  }
  if (this.upperBound != null) {
    type.upperBound=this.upperBound.getConcreteType(typeVariables);
  }
  if (this.upperBounds != null) {
    int len=this.upperBounds.size();
    if (len > 0) {
      type.upperBounds=new ArrayList(len);
      for (int i=0; i < len; i++) {
        type.upperBounds.add(this.upperBounds.get(i).getConcreteType(typeVariables));
      }
    }
  }
  return type;
}
Program: 85229
Project: 85229
Buggy source:
private void writeInvoke(MethodWriter writer,IValue instance,List<IValue> arguments){
  int args=0;
  if (instance != null) {
    instance.writeExpression(writer);
    args=1;
  }
  for (  IValue arg : arguments) {
    arg.writeExpression(writer);
    args++;
  }
  int opcode;
  int modifiers=this.modifiers;
  if ((modifiers & Modifiers.STATIC) != 0) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS) && (modifiers & Modifiers.ABSTRACT) != 0) {
    opcode=Opcodes.INVOKEINTERFACE;
  }
 else   if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else   if (instance != null && instance.getValueType() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.qualifiedName;
  String desc=this.getDescriptor();
  IType type=this.type;
  writer.visitMethodInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS),args,type);
}

Fixed version (ground truth):
private void writeInvoke(MethodWriter writer,IValue instance,List<IValue> arguments){
  int args=0;
  if (instance != null) {
    instance.writeExpression(writer);
    args=1;
  }
  for (  IValue arg : arguments) {
    arg.writeExpression(writer);
    args++;
  }
  int opcode;
  int modifiers=this.modifiers;
  if ((modifiers & Modifiers.STATIC) != 0) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS) && this.value == null) {
    opcode=Opcodes.INVOKEINTERFACE;
  }
 else   if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else   if (instance != null && instance.getValueType() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.qualifiedName;
  String desc=this.getDescriptor();
  IType type=this.type;
  writer.visitMethodInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS),args,type);
}
Program: 85230
Project: 85230
Buggy source:
@Override public Map<String,IType> getTypeMap(IValue instance,List<IValue> arguments,List<IType> typeArguments){
  Map<String,IType> map=new HashMap();
  if (typeArguments != null) {
    int len=Math.min(generics.size(),typeArguments.size());
    for (int i=0; i < len; i++) {
      ITypeVariable var=generics.get(i);
      IType type=typeArguments.get(i);
      map.put(var.getQualifiedName(),type);
    }
  }
  int len=arguments.size();
  int mods=this.modifiers & Modifiers.INFIX;
  if (instance != null && mods == Modifiers.INFIX) {
    instance.addTypeVariables(this.parameters.get(0).type,map);
    for (int i=0; i < len; i++) {
      Parameter par=this.parameters.get(i + 1);
      IValue v=arguments.get(i);
      v.addTypeVariables(par.type,map);
    }
    return map;
  }
  if (instance == null && len == 1 && (this.modifiers & Modifiers.PREFIX) != 0) {
    arguments.get(0).addTypeVariables(this.parameters.get(0).type,map);
    return map;
  }
  if (instance != null) {
    instance.addTypeVariables(this.theClass.getThisType(),map);
  }
  for (int i=0; i < len; i++) {
    Parameter par=this.parameters.get(i);
    IValue v=arguments.get(i);
    v.addTypeVariables(par.type,map);
  }
  return map;
}

Fixed version (ground truth):
@Override public Map<String,IType> getTypeMap(IValue instance,List<IValue> arguments,List<IType> typeArguments){
  Map<String,IType> map=new HashMap();
  if (typeArguments != null) {
    int len=Math.min(generics.size(),typeArguments.size());
    for (int i=0; i < len; i++) {
      ITypeVariable var=generics.get(i);
      IType type=typeArguments.get(i);
      map.put(var.getQualifiedName(),type);
    }
  }
  int len=arguments.size();
  int mods=this.modifiers & Modifiers.INFIX;
  if (instance != null && mods == Modifiers.INFIX) {
    instance.addTypeVariables(this.parameters.get(0).type,map);
    for (int i=0; i < len; i++) {
      Parameter par=this.parameters.get(i + 1);
      IValue v=arguments.get(i);
      v.addTypeVariables(par.type,map);
    }
    return map;
  }
  if (instance == null && len == 1 && (this.modifiers & Modifiers.PREFIX) != 0) {
    arguments.get(0).addTypeVariables(this.parameters.get(0).type,map);
    return map;
  }
  if (instance != null) {
    instance.addTypeVariables(this.theClass.getThisType(),map);
  }
  len=Math.min(this.parameters.size(),len);
  for (int i=0; i < len; i++) {
    Parameter par=this.parameters.get(i);
    IValue v=arguments.get(i);
    v.addTypeVariables(par.type,map);
  }
  return map;
}
Program: 85231
Project: 85231
Buggy source:
@Override public boolean parse(){
  ParserManager manager=new ParserManager(new CompilationUnitParser(this));
  manager.semicolonInference=true;
  manager.parse(this.inputFile,this.tokens);
  this.tokens=null;
  int size=this.markers.size();
  if (size > 0) {
    StringBuilder buffer=new StringBuilder("String_Node_Str");
    buffer.append(this.inputFile).append("String_Node_Str").append(size).append("String_Node_Str");
    boolean error=false;
    for (    Marker marker : this.markers) {
      marker.log(buffer);
    }
    DyvilCompiler.logger.info(buffer.toString());
    DyvilCompiler.logger.warning(this.name + "String_Node_Str");
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean parse(){
  ParserManager manager=new ParserManager(new CompilationUnitParser(this));
  manager.semicolonInference=true;
  manager.parse(this.inputFile,this.tokens);
  this.tokens=null;
  int size=this.markers.size();
  if (size > 0) {
    StringBuilder buffer=new StringBuilder("String_Node_Str");
    buffer.append(this.inputFile).append("String_Node_Str").append(size).append("String_Node_Str");
    boolean error=false;
    for (    Marker marker : this.markers) {
      marker.log(buffer);
    }
    DyvilCompiler.logger.info(buffer.toString());
    DyvilCompiler.logger.warning(this.name + "String_Node_Str");
    if (DyvilCompiler.states.contains(CompilerState.PRINT)) {
      DyvilCompiler.logger.info("String_Node_Str" + this.toString());
    }
    return false;
  }
  return true;
}
Program: 85232
Project: 85232
Buggy source:
public static void initLogger(){
  try {
    logger.setUseParentHandlers(false);
    Formatter formatter=new Formatter(){
      @Override public String format(      LogRecord record){
        String message=record.getMessage();
        if (message == null || message.isEmpty()) {
          return "String_Node_Str";
        }
        Throwable thrown=record.getThrown();
        StringBuilder builder=new StringBuilder();
        builder.append('[').append(format.format(new Date(record.getMillis()))).append("String_Node_Str");
        builder.append(record.getLevel()).append("String_Node_Str").append(message).append('\n');
        if (thrown != null) {
          thrown.printStackTrace(new AppendableOutputStream(builder));
        }
        return builder.toString();
      }
    }
;
    StreamHandler ch=new StreamHandler(System.out,formatter);
    logger.addHandler(ch);
    if (logFile) {
      String path=new File("String_Node_Str").getAbsolutePath();
      FileHandler fh=new FileHandler(path,true);
      fh.setFormatter(formatter);
      logger.addHandler(fh);
    }
  }
 catch (  Exception ex) {
  }
}

Fixed version (ground truth):
public static void initLogger(){
  try {
    logger.setUseParentHandlers(false);
    logger.setLevel(Level.ALL);
    Formatter formatter=new Formatter(){
      @Override public String format(      LogRecord record){
        String message=record.getMessage();
        if (message == null || message.isEmpty()) {
          return "String_Node_Str";
        }
        Throwable thrown=record.getThrown();
        StringBuilder builder=new StringBuilder();
        builder.append('[').append(format.format(new Date(record.getMillis()))).append("String_Node_Str");
        builder.append(record.getLevel()).append("String_Node_Str").append(message).append('\n');
        if (thrown != null) {
          thrown.printStackTrace(new AppendableOutputStream(builder));
        }
        return builder.toString();
      }
    }
;
    StreamHandler ch=new StreamHandler(System.out,formatter);
    ch.setLevel(Level.ALL);
    logger.addHandler(ch);
    if (logFile) {
      String path=new File("String_Node_Str").getAbsolutePath();
      FileHandler fh=new FileHandler(path,true);
      fh.setLevel(Level.ALL);
      fh.setFormatter(formatter);
      logger.addHandler(fh);
    }
  }
 catch (  Exception ex) {
  }
}
Program: 85233
Project: 85233
Buggy source:
@Override public void check(List<Marker> markers,IContext context){
  this.value.check(markers,context);
  if (this.type == Type.VOID) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
  boolean primitiveType=this.type.isPrimitive();
  IType type=this.value.getType();
  if (primitiveType) {
    if (!type.isPrimitive()) {
      markers.add(Markers.create(this.position,"String_Node_Str"));
    }
  }
 else   if (type.isPrimitive()) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
 else   if (this.value.isType(this.type)) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
}

Fixed version (ground truth):
@Override public void check(List<Marker> markers,IContext context){
  this.value.check(markers,context);
  if (this.type == Type.VOID) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (primitiveType) {
    if (!primitiveValue) {
      markers.add(Markers.create(this.position,"String_Node_Str"));
    }
  }
 else   if (primitiveValue) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
 else   if (this.value.isType(this.type)) {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
}
Program: 85234
Project: 85234
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  this.value.writeExpression(writer);
  if (this.type.isPrimitive()) {
    OpcodeUtil.writePrimitiveCast((PrimitiveType)this.value.getType(),(PrimitiveType)this.type,writer);
  }
 else {
    writer.visitTypeInsn(Opcodes.CHECKCAST,this.type);
  }
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  this.value.writeExpression(writer);
  if (this.type.isPrimitive()) {
    OpcodeUtil.writePrimitiveCast(this.value.getType(),(PrimitiveType)this.type,writer);
  }
 else {
    writer.visitTypeInsn(Opcodes.CHECKCAST,this.type);
  }
}
Program: 85235
Project: 85235
Buggy source:
public static void jar(List<File> files,File output,Manifest manifest){
  String outputDir=DyvilCompiler.config.outputDir.getAbsolutePath();
  int len=outputDir.length();
  if (!outputDir.endsWith("String_Node_Str")) {
    len++;
  }
  try (JarOutputStream jos=new JarOutputStream(new FileOutputStream(output),manifest)){
    for (    File file : files) {
      String name=file.getAbsolutePath().substring(len);
      createEntry(file,jos,name);
    }
    jos.flush();
  }
 catch (  Exception ex) {
    DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
  }
}

Fixed version (ground truth):
public static void jar(List<File> files,File output,Manifest manifest){
  String outputDir=DyvilCompiler.config.outputDir.getAbsolutePath();
  int len=outputDir.length();
  if (!outputDir.endsWith("String_Node_Str")) {
    len++;
  }
  try (JarOutputStream jos=new JarOutputStream(new FileOutputStream(output),manifest)){
    for (    File file : files) {
      if (file.exists()) {
        String name=file.getAbsolutePath().substring(len);
        createEntry(file,jos,name);
      }
    }
    jos.flush();
  }
 catch (  Exception ex) {
    DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
  }
}
Program: 85236
Project: 85236
Buggy source:
public static int index(String name){
switch (name) {
case "String_Node_Str":
    return 10;
case "String_Node_Str":
  return 20;
case "String_Node_Str":
return 30;
case "String_Node_Str":
return 40;
case "String_Node_Str":
return 50;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 60;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 70;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 80;
case "String_Node_Str":
case "String_Node_Str":
return 90;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 100;
case "String_Node_Str":
case "String_Node_Str":
return 200;
}
return 0;
}

Fixed version (ground truth):
public static int index(String name){
switch (name) {
case "String_Node_Str":
    return 10;
case "String_Node_Str":
  return 20;
case "String_Node_Str":
return 30;
case "String_Node_Str":
return 40;
case "String_Node_Str":
return 50;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 60;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 70;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 80;
case "String_Node_Str":
case "String_Node_Str":
return 90;
case "String_Node_Str":
case "String_Node_Str":
case "String_Node_Str":
return 100;
case "String_Node_Str":
case "String_Node_Str":
return 110;
case "String_Node_Str":
case "String_Node_Str":
return 200;
}
if (name.charAt(name.length() - 1) == '=') {
return 5;
}
return 0;
}
Program: 85237
Project: 85237
Buggy source:
public static void writePrimitiveCast(PrimitiveType value,PrimitiveType cast,MethodWriter writer){
switch (value.typecode) {
case Opcodes.T_BYTE:
case Opcodes.T_SHORT:
case Opcodes.T_BOOLEAN:
case Opcodes.T_CHAR:
case Opcodes.T_INT:
    writeIntCast(cast,writer);
  break;
case Opcodes.T_LONG:
writeLongCast(cast,writer);
break;
case Opcodes.T_FLOAT:
writeFloatCast(cast,writer);
break;
case Opcodes.T_DOUBLE:
writeDoubleCast(cast,writer);
break;
}
}

Fixed version (ground truth):
public static void writePrimitiveCast(IType value,PrimitiveType cast,MethodWriter writer){
  IClass iclass=value.getTheClass();
  if (iclass == Type.BYTE_CLASS || iclass == Type.SHORT_CLASS || iclass == Type.CHAR_CLASS || iclass == Type.INT_CLASS) {
    writeIntCast(cast,writer);
    return;
  }
  if (iclass == Type.LONG_CLASS) {
    writeLongCast(cast,writer);
    return;
  }
  if (iclass == Type.FLOAT_CLASS) {
    writeFloatCast(cast,writer);
    return;
  }
  if (iclass == Type.DOUBLE_CLASS) {
    writeDoubleCast(cast,writer);
    return;
  }
}
Program: 85238
Project: 85238
Buggy source:
public static @infix @inline <K,V>void $plus$eq(Map<K,V> map,K key,V value){
  map.put(key,value);
}

Fixed version (ground truth):
public static @infix @inline <K,V>void $plus$eq(Map<K,V> map,Tuple2<K,V> tuple){
  map.put(tuple._1,tuple._2);
}
Program: 85239
Project: 85239
Buggy source:
@Override public void addTypeVariables(IType type,Map<String,IType> typeVariables){
  if (type instanceof ITypeVariable) {
    if (type.isSuperTypeOf(this)) {
      if (this.arrayDimensions > 0) {
        typeVariables.put(type.getQualifiedName(),this.getArrayType(this.arrayDimensions - type.getArrayDimensions()));
      }
 else {
        typeVariables.put(type.getQualifiedName(),this);
      }
    }
  }
 else   if (type instanceof GenericType) {
    List<IType> types=((GenericType)type).generics;
    int len=Math.min(this.generics.size(),types.size());
    for (int i=0; i < len; i++) {
      IType t1=types.get(i);
      IType t2=this.generics.get(i);
      System.out.println(t1 + "String_Node_Str" + t2);
      t1.addTypeVariables(t2,typeVariables);
      t2.addTypeVariables(t1,typeVariables);
    }
  }
}

Fixed version (ground truth):
@Override public void addTypeVariables(IType type,Map<String,IType> typeVariables){
  if (type instanceof ITypeVariable) {
    if (type.isSuperTypeOf(this)) {
      if (this.arrayDimensions > 0) {
        typeVariables.put(type.getQualifiedName(),this.getArrayType(this.arrayDimensions - type.getArrayDimensions()));
      }
 else {
        typeVariables.put(type.getQualifiedName(),this);
      }
    }
  }
  if (this.generics != null) {
    if (type instanceof GenericType) {
      List<IType> types=((GenericType)type).generics;
      int len=Math.min(this.generics.size(),types.size());
      for (int i=0; i < len; i++) {
        IType t1=types.get(i);
        IType t2=this.generics.get(i);
        t1.addTypeVariables(t2,typeVariables);
        t2.addTypeVariables(t1,typeVariables);
      }
    }
    List<ITypeVariable> variables=this.theClass.getTypeVariables();
    if (variables != null) {
      int len=Math.min(this.generics.size(),variables.size());
      for (int i=0; i < len; i++) {
        ITypeVariable var=variables.get(i);
        IType type1=this.generics.get(i);
        typeVariables.put(var.getQualifiedName(),type);
      }
    }
  }
}
Program: 85240
Project: 85240
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,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);
  }
}

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)) {
      f.writeGet(writer,null);
      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: 85241
Project: 85241
Buggy source:
public default IValue withType(IType type){
  IType type1=this.getType();
  if (type1 == null) {
    return null;
  }
  boolean primitive=type1.isPrimitive();
  if (primitive != type.isPrimitive()) {
    if (!Type.isSuperType(type,type1)) {
      return null;
    }
    if (primitive) {
      return type1.box(this);
    }
 else {
      return type.unbox(this);
    }
  }
  if (Type.isSuperType(type,type1)) {
    return this;
  }
  return null;
}

Fixed version (ground truth):
public default IValue withType(IType type){
  IType type1=this.getType();
  if (type1 == null) {
    return null;
  }
  boolean primitive=this.isPrimitive();
  if (primitive != type.isPrimitive()) {
    if (!Type.isSuperType(type,type1)) {
      return null;
    }
    if (primitive) {
      return type1.box(this);
    }
 else {
      return type.unbox(this);
    }
  }
  if (Type.isSuperType(type,type1)) {
    return this;
  }
  return null;
}
Program: 85243
Project: 85243
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.elseThen != null) {
    this.condition.writeJump(writer,this.elseStart);
    this.then.writeStatement(writer);
    writer.visitJumpInsn(Opcodes.GOTO,this.elseEnd);
    writer.visitLabel(this.elseStart);
    this.elseThen.writeStatement(writer);
    writer.visitLabel(this.elseEnd);
  }
 else {
    this.condition.writeJump(writer,this.elseStart);
    this.then.writeStatement(writer);
    writer.visitLabel(this.elseStart);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.elseThen != null) {
    this.condition.writeJump(writer,this.elseStart);
    this.then.writeStatement(writer);
    writer.visitJumpInsn(Opcodes.GOTO,this.elseEnd);
    writer.visitLabel(this.elseStart);
    this.elseThen.writeStatement(writer);
    writer.visitLabel(this.elseEnd,this.parent == null || this.parent.canVisitStack(this));
  }
 else {
    this.condition.writeJump(writer,this.elseStart);
    this.then.writeStatement(writer);
    writer.visitLabel(this.elseStart,this.parent == null || this.parent.canVisitStack(this));
  }
}
Program: 85244
Project: 85244
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  this.condition.writeJump(writer,this.elseStart);
  this.then.writeExpression(writer);
  writer.pop();
  writer.visitJumpInsn(Opcodes.GOTO,this.elseEnd);
  writer.visitLabel(this.elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer);
  }
  writer.visitLabel(this.elseEnd);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  this.condition.writeJump(writer,this.elseStart);
  this.then.writeExpression(writer);
  writer.pop();
  writer.visitJumpInsn(Opcodes.GOTO,this.elseEnd);
  writer.visitLabel(this.elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer);
  }
  writer.visitLabel(this.elseEnd,this.parent == null || this.parent.canVisitStack(this));
}
Program: 85245
Project: 85245
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  writer.visitLabel2(this.start);
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.addLocal(var.index,var.type);
  }
  String label;
  for (  IValue v : this.values) {
    if (this.valueLabels != null && (label=this.valueLabels.get(v)) != null) {
      writer.visitLabel(this.labels.get(label));
    }
    v.writeStatement(writer);
  }
  writer.visitLabel2(this.end);
  int count=0;
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.visitLocalVariable(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),this.start,this.end,var.index);
    count++;
  }
  writer.removeLocals(count);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  writer.visitLabel(this.start,false);
  int count=0;
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.addLocal(var.index,var.type);
    count++;
  }
  String label;
  for (  IValue v : this.values) {
    if (this.valueLabels != null && (label=this.valueLabels.get(v)) != null) {
      writer.visitLabel(this.labels.get(label));
    }
    v.writeStatement(writer);
  }
  writer.removeLocals(count);
  writer.visitLabel(this.end,count > 0 && (this.parent == null || this.parent.canVisitStack(this)));
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.visitLocalVariable(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),this.start,this.end,var.index);
  }
}
Program: 85246
Project: 85246
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,this.parent == null || this.parent.canVisitStack(this));
}
Program: 85247
Project: 85247
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.condition.resolveTypes(markers,context);
  if (this.then.isStatement()) {
    ((IStatement)this.then).setParent(this);
    this.then.resolveTypes(markers,context);
  }
 else   if (this.then != null) {
    this.then.resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.condition.resolveTypes(markers,context);
  if (this.then != null) {
    if (this.then.isStatement()) {
      ((IStatement)this.then).setParent(this);
      this.then.resolveTypes(markers,context);
    }
 else {
      this.then.resolveTypes(markers,context);
    }
  }
}
Program: 85249
Project: 85249
Buggy source:
@Override public void visitJumpInsn(int opcode,Label label){
  if (opcode >= IFEQ && opcode <= IFLE) {
    this.visitFrame();
    this.pop();
  }
  if (opcode >= IF_ICMPEQ && opcode <= IF_ICMPLE) {
    this.visitFrame();
    this.stackIndex-=2;
    this.stackCount-=2;
  }
  this.stackChanged=true;
  this.mv.visitJumpInsn(opcode,label);
}

Fixed version (ground truth):
@Override public void visitJumpInsn(int opcode,Label label){
  if (opcode >= IFEQ && opcode <= IFLE) {
    this.visitFrame();
    this.pop();
  }
  if (opcode >= IF_ICMPEQ && opcode <= IF_ICMPLE) {
    this.visitFrame();
    this.stackIndex-=2;
    this.stackCount-=2;
  }
  this.mv.visitJumpInsn(opcode,label);
}
Program: 85250
Project: 85250
Buggy source:
public void pop(){
  this.stackChanged=true;
  this.stackIndex--;
  this.stackCount--;
}

Fixed version (ground truth):
public void pop(){
  this.stackIndex--;
  this.stackCount--;
}
Program: 85251
Project: 85251
Buggy source:
@Override public void visitLabel(Label label){
  if (this.stackChanged) {
    this.visitFrame();
    this.stackChanged=false;
  }
  this.mv.visitLabel(label);
}

Fixed version (ground truth):
public void visitLabel(Label label,boolean stack){
  if (stack) {
    this.visitFrame();
  }
  this.mv.visitLabel(label);
}
Program: 85252
Project: 85252
Buggy source:
public void push(IType type){
  Object frameType=type.getFrameType();
  if (frameType != null) {
    this.ensureStack(this.stackIndex + 1);
    this.stackChanged=true;
    this.stack[this.stackIndex++]=type;
  }
}

Fixed version (ground truth):
public void push(IType type){
  Object frameType=type.getFrameType();
  if (frameType != null) {
    this.ensureStack(this.stackIndex + 1);
    this.stack[this.stackIndex++]=type;
  }
}
Program: 85253
Project: 85253
Buggy source:
@Override public void visitInsn(int opcode){
  if (opcode > 255) {
    this.visitSpecialInsn(opcode);
    return;
  }
 else   if (opcode >= IASTORE && opcode <= SASTORE) {
    this.stackIndex-=3;
    this.stackCount-=3;
    this.stackChanged=true;
  }
 else   if (opcode >= IRETURN && opcode <= ARETURN) {
    this.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.stackIndex-=3;
    this.stackCount-=3;
  }
 else   if (opcode >= IRETURN && opcode <= ARETURN) {
    this.pop();
  }
 else {
    this.processInsn(opcode);
  }
  this.mv.visitInsn(opcode);
}
Program: 85254
Project: 85254
Buggy source:
public void visitJumpInsn2(int opcode,Label label){
  if (opcode >= IFEQ && opcode <= IFLE) {
    this.pop();
  }
  if (opcode >= IF_ICMPEQ && opcode <= IF_ICMPLE) {
    this.stackIndex-=2;
    this.stackCount-=2;
  }
  this.stackChanged=true;
  this.mv.visitJumpInsn(opcode,label);
}

Fixed version (ground truth):
public void visitJumpInsn2(int opcode,Label label){
  if (opcode >= IFEQ && opcode <= IFLE) {
    this.pop();
  }
  if (opcode >= IF_ICMPEQ && opcode <= IF_ICMPLE) {
    this.stackIndex-=2;
    this.stackCount-=2;
  }
  this.mv.visitJumpInsn(opcode,label);
}
Program: 85255
Project: 85255
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);
    writer.visitInsn(Opcodes.DUP);
    call.method.writeCall(writer,null,call.arguments);
    this.method.writeCall(writer,null,this.arguments);
    this.updateMethod.writeCall(writer,null,call.arguments);
  }
}

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);
    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);
  }
}
Program: 85256
Project: 85256
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);
    writer.visitInsn(Opcodes.SWAP);
    f.writeSet(writer);
  }
 else   if (i == APPLY_METHOD_CALL) {
    ApplyMethodCall call=(ApplyMethodCall)this.instance;
    call.writeExpression(writer);
    writer.visitInsn(Opcodes.DUP);
    this.method.writeCall(writer,null,this.arguments);
    this.updateMethod.writeCall(writer,call,call.arguments);
  }
}

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);
    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);
  }
}
Program: 85257
Project: 85257
Buggy source:
@Override public Package resolvePackage(String name){
  return null;
}

Fixed version (ground truth):
@Override public Package resolvePackage(String name){
  return this.unit.resolvePackage(name);
}
Program: 85258
Project: 85258
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  writer.visitLabel(this.start,false);
  int count=0;
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.addLocal(var.index,var.type);
    count++;
  }
  String label;
  for (  IValue v : this.values) {
    if (this.valueLabels != null && (label=this.valueLabels.get(v)) != null) {
      writer.visitLabel(this.labels.get(label));
    }
    v.writeStatement(writer);
  }
  writer.removeLocals(count);
  writer.visitLabel(this.end,count > 0 && (this.parent == null || this.parent.canVisitStack(this)));
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.visitLocalVariable(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),this.start,this.end,var.index);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  writer.visitLabel(this.start,false);
  int count=0;
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.addLocal(var.index,var.type);
    count++;
  }
  String label;
  for (  IValue v : this.values) {
    if (this.valueLabels != null && (label=this.valueLabels.get(v)) != null) {
      writer.visitLabel(this.labels.get(label));
    }
    v.writeStatement(writer);
  }
  if (this.parent != null || !(this.context instanceof IMethod)) {
    writer.removeLocals(count);
    writer.visitLabel(this.end,count > 0 && (this.parent == null || this.parent.canVisitStack(this)));
  }
 else   if (!writer.hasReturn) {
    writer.visitInsn(this.requiredType.getReturnOpcode());
  }
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.visitLocalVariable(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),this.start,this.end,var.index);
  }
}
Program: 85259
Project: 85259
Buggy source:
public void tokenize(){
  this.tokens=DyvilCompiler.parser.tokenize(this.inputFile);
}

Fixed version (ground truth):
public void tokenize(){
  Dlex lexer=new Dlex(this.inputFile);
  lexer.tokenize();
  this.tokens=lexer.iterator();
}
Program: 85261
Project: 85261
Buggy source:
public void push(IType type){
  Object frameType=type.getFrameType();
  if (frameType != null) {
    this.ensureStack(this.stackIndex + 1);
    this.stack[this.stackIndex++]=type;
  }
}

Fixed version (ground truth):
public void push(IType type){
  Object frameType=type.getFrameType();
  if (frameType != null) {
    this.ensureStack(this.stackIndex + 1);
    this.stack[this.stackIndex++]=frameType;
  }
}
Program: 85262
Project: 85262
Buggy source:
public final void parse(CodeFile file,TokenIterator tokens){
  IToken token=null;
  this.tokens=tokens;
  try {
    IToken prev=null;
    while (tokens.hasNext()) {
      token=tokens.next();
      if (!this.retainToken((Token)token,prev)) {
        tokens.remove();
      }
      prev=token;
    }
    int index=0;
    tokens.reset();
    while (tokens.hasNext()) {
      token=tokens.next();
      token.setIndex(index);
      token.setPrev(prev);
      index++;
      prev=token;
    }
    tokens.reset();
    while (tokens.hasNext()) {
      token=this.currentToken=tokens.next();
      if (this.skip > 0) {
        this.skip--;
        continue;
      }
      Parser parser=this.currentParser;
      try {
        this.parseToken(parser,token);
      }
 catch (      SyntaxError ex) {
        if (this.jumpBackToken != null) {
          tokens.jump(this.jumpBackToken);
          this.popParser();
          this.jumpBackToken=null;
        }
 else {
          this.file.markers.add(ex);
        }
      }
      if (DyvilCompiler.parseStack) {
        System.out.println(token + "String_Node_Str" + parser.name+ "String_Node_Str"+ parser.mode);
      }
    }
  }
 catch (  Exception ex) {
    ex.printStackTrace();
  }
}

Fixed version (ground truth):
public final void parse(CodeFile file,TokenIterator tokens){
  IToken token=null;
  this.tokens=tokens;
  this.file=file;
  try {
    IToken prev=null;
    while (tokens.hasNext()) {
      token=tokens.next();
      if (!this.retainToken((Token)token,prev)) {
        tokens.remove();
      }
      prev=token;
    }
    int index=0;
    tokens.reset();
    while (tokens.hasNext()) {
      token=tokens.next();
      token.setIndex(index);
      token.setPrev(prev);
      index++;
      prev=token;
    }
    tokens.reset();
    while (tokens.hasNext()) {
      token=this.currentToken=tokens.next();
      if (this.skip > 0) {
        this.skip--;
        continue;
      }
      Parser parser=this.currentParser;
      try {
        this.parseToken(parser,token);
      }
 catch (      SyntaxError ex) {
        if (this.jumpBackToken != null) {
          tokens.jump(this.jumpBackToken);
          this.popParser();
          this.jumpBackToken=null;
        }
 else {
          this.file.markers.add(ex);
        }
      }
      if (DyvilCompiler.parseStack) {
        System.out.println(token + "String_Node_Str" + parser.name+ "String_Node_Str"+ parser.mode);
      }
    }
  }
 catch (  Exception ex) {
    ex.printStackTrace();
  }
}
Program: 85263
Project: 85263
Buggy source:
public void resolveTypes(List<Marker> markers,IContext context){
  this.type=this.type.resolve(context);
  if (!this.type.isResolved()) {
    markers.add(Markers.create(this.position,"String_Node_Str",this.name));
  }
  for (  Entry<String,IValue> entry : this.parameters.entrySet()) {
    entry.getValue().resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
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.position,"String_Node_Str",this.name));
  }
  for (  Entry<String,IValue> entry : this.parameters.entrySet()) {
    entry.getValue().resolveTypes(markers,context);
  }
}
Program: 85264
Project: 85264
Buggy source:
@Override public IClass resolveClass(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  IClass clazz=this.body.getClass(name);
  if (clazz != null) {
    return clazz;
  }
  return null;
}

Fixed version (ground truth):
@Override public IClass resolveClass(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  if (this.generics != null) {
    for (    ITypeVariable var : this.generics) {
      if (var.isName(name)) {
        return var.getTheClass();
      }
    }
  }
  IClass clazz=this.body.getClass(name);
  if (clazz != null) {
    return clazz;
  }
  return null;
}
Program: 85265
Project: 85265
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.typesResolved=true;
  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);
    }
  }
  for (  Annotation a : this.annotations) {
    a.resolveTypes(markers,Package.rootPackage);
  }
  this.body.resolveTypes(markers,Package.rootPackage);
  if (this.outerType != null) {
    this.outerClass=this.outerType.resolve(context).getTheClass();
  }
  if (this.innerTypes != null) {
    for (    IType t : this.innerTypes) {
      IClass iclass=t.resolve(context).getTheClass();
      this.body.addClass(iclass);
    }
    this.innerTypes=null;
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.typesResolved=true;
  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,context);
    }
  }
  this.body.resolveTypes(markers,this);
  if (this.outerType != null) {
    this.outerClass=this.outerType.resolve(context).getTheClass();
  }
  if (this.innerTypes != null) {
    for (    IType t : this.innerTypes) {
      IClass iclass=t.resolve(context).getTheClass();
      this.body.addClass(iclass);
    }
    this.innerTypes=null;
  }
}
Program: 85266
Project: 85266
Buggy source:
@Override public void resolve(List<Marker> markers,IContext context){
  for (Iterator<Annotation> iterator=this.annotations.iterator(); iterator.hasNext(); ) {
    Annotation a=iterator.next();
    if (this.processAnnotation(a)) {
      iterator.remove();
      continue;
    }
    a.resolve(markers,context);
  }
  if ((this.modifiers & Modifiers.OBJECT_CLASS) != 0) {
    this.instanceField=new Field(this,"String_Node_Str",this.getType(),Modifiers.PUBLIC | Modifiers.CONST | Modifiers.SYNTHETIC,Collections.EMPTY_LIST);
  }
  if (this.body != null) {
    this.body.resolve(markers,this);
  }
}

Fixed version (ground truth):
@Override public void resolve(List<Marker> markers,IContext context){
  if (this.annotations != null) {
    Iterator<Annotation> iterator=this.annotations.iterator();
    while (iterator.hasNext()) {
      Annotation a=iterator.next();
      if (this.processAnnotation(a)) {
        iterator.remove();
        continue;
      }
      a.resolve(markers,context);
    }
  }
  if ((this.modifiers & Modifiers.OBJECT_CLASS) != 0) {
    this.instanceField=new Field(this,"String_Node_Str",this.getType(),Modifiers.PUBLIC | Modifiers.CONST | Modifiers.SYNTHETIC,Collections.EMPTY_LIST);
  }
  if (this.body != null) {
    this.body.resolve(markers,this);
  }
}