nus-yam/ex-repair huggingface dataset:
Program: 84797
Project: 84797
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.condition != null) {
    this.condition.checkTypes(markers,this);
  }
  if (this.type != Types.UNKNOWN) {
    IClass iclass=context.getThisClass();
    IDyvilHeader unit=iclass.getUnit();
    this.internalClassName=iclass.getInternalName() + "String_Node_Str" + unit.innerClassCount();
    unit.addInnerClass(this);
    if (this.pattern != null) {
      this.pattern.resolve(markers,context);
      IType type1=this.type.resolveType(PAR_TYPE);
      this.pattern=this.pattern.withType(type1);
      this.pattern.checkTypes(markers,context);
    }
    if (this.value != null) {
      IType type1=this.type.resolveType(RETURN_TYPE);
      this.value=this.value.withType(type1);
    }
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
  this.context=null;
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.condition != null) {
    this.condition.checkTypes(markers,this);
  }
  if (this.type != Types.UNKNOWN) {
    if (this.type == null) {
      this.getType();
    }
    IClass iclass=context.getThisClass();
    IDyvilHeader unit=iclass.getUnit();
    this.internalClassName=iclass.getInternalName() + "String_Node_Str" + unit.innerClassCount();
    unit.addInnerClass(this);
    if (this.pattern != null) {
      this.pattern.resolve(markers,context);
      IType type1=this.type.resolveType(PAR_TYPE);
      this.pattern=this.pattern.withType(type1);
      this.pattern.checkTypes(markers,context);
    }
    if (this.value != null) {
      IType type1=this.type.resolveType(RETURN_TYPE);
      this.value=this.value.withType(type1);
    }
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
  this.context=null;
}
Program: 84799
Project: 84799
Buggy source:
@Override public IType getType(){
  if (this.type == null) {
    GenericType gt=new GenericType(PARTIALFUNCTION_CLASS);
    IType t1=this.pattern.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    t1=this.value.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    return this.type=gt;
  }
  return this.type;
}

Fixed version (ground truth):
@Override public IType getType(){
  if (this.type == null) {
    GenericType gt=new GenericType(PARTIALFUNCTION_CLASS);
    IType t1=this.pattern.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    if (this.value != null) {
      t1=this.value.getType();
      if (t1.isPrimitive()) {
        t1=t1.getReferenceType();
      }
      gt.addType(t1);
    }
 else {
      gt.addType(new Type(Types.VOID_CLASS));
    }
    return this.type=gt;
  }
  return this.type;
}
Program: 84800
Project: 84800
Buggy source:
public default IValue withType(IType type){
  IType thisType=this.getType();
  if (thisType == null) {
    return null;
  }
  if (!type.isSuperTypeOf(thisType)) {
    return null;
  }
  boolean primitive=this.isPrimitive();
  if (primitive != type.isPrimitive()) {
    if (primitive) {
      return new BoxedValue(this,thisType.getBoxMethod());
    }
    return new BoxedValue(this,type.getUnboxMethod());
  }
  return this;
}

Fixed version (ground truth):
public default IValue withType(IType type){
  IType thisType=this.getType();
  if (thisType == null) {
    return null;
  }
  if (!type.isSuperTypeOf(thisType)) {
    return null;
  }
  boolean primitive=thisType.isPrimitive();
  if (primitive != type.isPrimitive()) {
    if (primitive) {
      return new BoxedValue(this,thisType.getBoxMethod());
    }
    return new BoxedValue(this,type.getUnboxMethod());
  }
  return this;
}
Program: 84801
Project: 84801
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  for (int i=0; i < this.caseCount; i++) {
    CaseStatement c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.pattern;
    pattern.resolve(markers,context);
    if (pattern.isExhaustive()) {
      if (c.condition == null) {
        this.exhaustive=true;
      }
    }
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
 else {
      c.pattern=pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
    this.cases[i].resolve(markers,context);
  }
  if (type == Types.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  for (int i=0; i < this.caseCount; i++) {
    CaseStatement c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.pattern;
    pattern=pattern.resolve(markers,context);
    if (pattern.isExhaustive()) {
      if (c.condition == null) {
        this.exhaustive=true;
      }
    }
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
 else {
      pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
    c.pattern=pattern;
    this.cases[i].resolve(markers,context);
  }
  if (type == Types.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}
Program: 84802
Project: 84802
Buggy source:
public static MatchExpression getMatchExpression(IValue arg1,IValue arg2){
  if (arg2.valueTag() == IValue.STATEMENT_LIST) {
    IValueList list=(IValueList)arg2;
    int len=list.valueCount();
    CaseStatement[] cases=new CaseStatement[len];
    for (int i=0; i < len; i++) {
      IValue v=list.getValue(i);
      if (v.valueTag() != IValue.CASE_STATEMENT) {
        return null;
      }
      cases[i]=(CaseStatement)v;
      cases[i].setMatchCase();
    }
    return new MatchExpression(arg1,cases);
  }
  if (arg2.valueTag() == IValue.CASE_STATEMENT) {
    return new MatchExpression(arg1,new CaseStatement[]{(CaseStatement)arg2});
  }
  return null;
}

Fixed version (ground truth):
public static MatchExpression getMatchExpression(IValue arg1,IValue arg2){
  if (arg2.valueTag() == IValue.STATEMENT_LIST) {
    IValueList list=(IValueList)arg2;
    int len=list.valueCount();
    CaseStatement[] cases=new CaseStatement[len];
    for (int i=0; i < len; i++) {
      IValue v=list.getValue(i);
      if (v.valueTag() != IValue.CASE_STATEMENT) {
        return null;
      }
      cases[i]=(CaseStatement)v;
      cases[i].setMatchCase();
    }
    return new MatchExpression(arg1,cases);
  }
  if (arg2.valueTag() == IValue.CASE_STATEMENT) {
    CaseStatement cs=(CaseStatement)arg2;
    cs.setMatchCase();
    return new MatchExpression(arg1,new CaseStatement[]{cs});
  }
  return null;
}
Program: 84803
Project: 84803
Buggy source:
@Override public boolean isExhaustive(){
  return true;
}

Fixed version (ground truth):
@Override public boolean isExhaustive(){
  return this.type == Types.ANY || this.type == Types.UNKNOWN;
}
Program: 84804
Project: 84804
Buggy source:
@Override public IPattern withType(IType type){
  this.type=type;
  return this;
}

Fixed version (ground truth):
@Override public IPattern withType(IType type){
  if (this.type == Types.ANY || this.type == Types.UNKNOWN) {
    this.type=type;
    return this;
  }
  return type.isSuperTypeOf(this.type) ? this : null;
}
Program: 84805
Project: 84805
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
}

Fixed version (ground truth):
@Override public IPattern resolve(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  for (int i=0; i < this.patternCount; i++) {
    this.patterns[i]=this.patterns[i].resolve(markers,context);
  }
  return this;
}
Program: 84806
Project: 84806
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  int paramCount=iclass.parameterCount();
  if (this.patternCount != paramCount) {
    Marker m=markers.create(this.position,"String_Node_Str",this.type.toString());
    m.addInfo("String_Node_Str" + this.patternCount);
    m.addInfo("String_Node_Str" + paramCount);
    return;
  }
  for (int i=0; i < paramCount; i++) {
    IParameter param=iclass.getParameter(i);
    IType type=param.getType().getConcreteType(this.type);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(this.position,"String_Node_Str",param.getName());
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  int paramCount=iclass.parameterCount();
  if (this.patternCount != paramCount) {
    Marker m=markers.create(this.position,"String_Node_Str",this.type.toString());
    m.addInfo("String_Node_Str" + this.patternCount);
    m.addInfo("String_Node_Str" + paramCount);
    return;
  }
  for (int i=0; i < paramCount; i++) {
    IParameter param=iclass.getParameter(i);
    IType type=param.getType().getConcreteType(this.type);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(this.position,"String_Node_Str",param.getName());
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
  }
}
Program: 84807
Project: 84807
Buggy source:
public default void resolve(MarkerList markers,IContext context){
}

Fixed version (ground truth):
public default IPattern resolve(MarkerList markers,IContext context){
  return this;
}
Program: 84808
Project: 84808
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  ITypeList typeList=(ITypeList)this.tupleType;
  for (int i=0; i < this.patternCount; i++) {
    IType type=typeList.getType(i);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  ITypeList typeList=(ITypeList)this.tupleType;
  for (int i=0; i < this.patternCount; i++) {
    IType type=typeList.getType(i);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
  }
}
Program: 84809
Project: 84809
Buggy source:
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    varIndex=writer.localCount();
    writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  }
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.INSTANCEOF,this.type.getInternalName());
  writer.writeJumpInsn(Opcodes.IFEQ,elseLabel);
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
  this.pattern.writeInvJump(writer,-1,elseLabel);
  writer.resetLocals(varIndex);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    varIndex=writer.localCount();
    writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  }
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.INSTANCEOF,this.type.getInternalName());
  writer.writeJumpInsn(Opcodes.IFEQ,elseLabel);
  if (this.pattern.getPatternType() != WILDCARD) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
    writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    this.pattern.writeInvJump(writer,-1,elseLabel);
  }
}
Program: 84810
Project: 84810
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  this.pattern.toString(prefix,buffer);
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.pattern != null) {
    this.pattern.toString(prefix,buffer);
  }
  if (!this.pattern.isType(this.type)) {
    buffer.append("String_Node_Str");
    this.type.toString(prefix,buffer);
  }
}
Program: 84811
Project: 84811
Buggy source:
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    writer.writeInsn(Opcodes.AUTO_POP);
  }
}
Program: 84812
Project: 84812
Buggy source:
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  writer.writeInsn(Opcodes.AUTO_POP);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    writer.writeInsn(Opcodes.AUTO_POP);
  }
}
Program: 84814
Project: 84814
Buggy source:
protected void processValue(){
  if (this.value == null) {
    return;
  }
  MarkerList markers=new MarkerList();
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  IValue value=this.value;
  IType type=Types.UNKNOWN;
  ICodePosition position=CODE_POSITION;
  this.value=null;
  REPLVariable field=new REPLVariable(position,name,type,value);
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  field.foldConstants();
  if (this.reportErrors(markers)) {
    return;
  }
  field.compute();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}

Fixed version (ground truth):
protected void processValue(){
  if (this.value == null) {
    return;
  }
  MarkerList markers=new MarkerList();
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  IValue value=this.value;
  IType type=Types.UNKNOWN;
  ICodePosition position=CODE_POSITION;
  this.value=null;
  REPLVariable field=new REPLVariable(position,name,type,value);
  field.modifiers=Modifiers.FINAL;
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    return;
  }
  field.foldConstants();
  field.compute();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}
Program: 84815
Project: 84815
Buggy source:
protected void compute(){
  if (this.className != null || this.value.isConstant())   return;
  try {
    this.className="String_Node_Str" + classID++;
    Class c=generateClass(this.value,this.type,this.className);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}

Fixed version (ground truth):
protected void compute(){
  if (this.className != null || isConstant(this.value))   return;
  try {
    this.className="String_Node_Str" + classID++;
    Class c=generateClass(this.value,this.type,this.className);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}
Program: 84816
Project: 84816
Buggy source:
@Override public void writeGet(MethodWriter writer,IValue instance) throws BytecodeException {
  if (this.value.isConstant()) {
    this.value.writeExpression(writer);
    return;
  }
  if (this.className == null) {
    this.type.writeDefaultValue(writer);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.GETSTATIC,this.className,"String_Node_Str",extended);
}

Fixed version (ground truth):
@Override public void writeGet(MethodWriter writer,IValue instance) throws BytecodeException {
  if (isConstant(this.value)) {
    this.value.writeExpression(writer);
    return;
  }
  if (this.className == null) {
    this.type.writeDefaultValue(writer);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.GETSTATIC,this.className,"String_Node_Str",extended);
}
Program: 84817
Project: 84817
Buggy source:
private IDyvilHeader loadHeader(String fileName,String name,Library library){
  InputStream is=library.getInputStream(fileName);
  if (is != null) {
    IDyvilHeader header=HeaderFile.read(is);
    this.units.add(header);
    return header;
  }
  return null;
}

Fixed version (ground truth):
private IDyvilHeader loadHeader(String fileName,String name,Library library){
  InputStream is=library.getInputStream(fileName);
  if (is != null) {
    DyvilHeader header=HeaderFile.read(is);
    header.pack=this;
    this.units.add(header);
    return header;
  }
  return null;
}
Program: 84818
Project: 84818
Buggy source:
@Override public void addInclude(IncludeDeclaration component){
  if (this.includes == null) {
    this.includes=new IncludeDeclaration[2];
    this.includes[0]=component;
    this.includeCount=1;
    if (!this.isHeader()) {
      this.inheritedOperators=new IdentityHashMap();
    }
  }
 else {
    int index=this.includeCount++;
    if (index >= this.includes.length) {
      IncludeDeclaration[] temp=new IncludeDeclaration[index + 1];
      System.arraycopy(this.includes,0,temp,0,this.includes.length);
      this.includes=temp;
    }
    this.includes[index]=component;
  }
  if (this.isHeader()) {
    this.markers.add(component.getPosition(),"String_Node_Str");
    return;
  }
  component.resolve(this.markers);
  component.addOperators(this.inheritedOperators);
}

Fixed version (ground truth):
@Override public void addInclude(IncludeDeclaration component){
  this.addIncludeToArray(component);
  if (this.isHeader()) {
    this.markers.add(component.getPosition(),"String_Node_Str");
    return;
  }
  component.resolve(this.markers);
  component.addOperators(this.inheritedOperators);
}
Program: 84820
Project: 84820
Buggy source:
protected void processHeader(){
  MarkerList markers=new MarkerList();
  if (tempClass != null) {
    tempClass.resolveTypes(markers,this);
    tempClass.resolve(markers,this);
    tempClass.checkTypes(markers,this);
    tempClass.check(markers,this);
    tempClass.foldConstants();
    super.addClass(tempClass);
    System.out.println("String_Node_Str" + tempClass.getName());
    tempClass=null;
  }
  if (this.headerComponent == null || this.headerComponent.theImport == null) {
    return;
  }
  headerComponent.resolveTypes(markers,this,false);
  if (this.reportErrors(markers)) {
    return;
  }
  boolean isStatic=headerComponent.isStatic;
  if (isStatic) {
    super.addStaticImport(headerComponent);
    System.out.println("String_Node_Str" + headerComponent.theImport);
  }
 else {
    super.addImport(headerComponent);
    System.out.println("String_Node_Str" + headerComponent.theImport);
  }
  headerComponent=null;
}

Fixed version (ground truth):
protected void processHeader(){
  MarkerList markers=new MarkerList();
  if (tempClass != null) {
    tempClass.resolveTypes(markers,this);
    tempClass.resolve(markers,this);
    tempClass.checkTypes(markers,this);
    tempClass.check(markers,this);
    tempClass.foldConstants();
    super.addClass(tempClass);
    System.out.println("String_Node_Str" + tempClass.getName());
    tempClass=null;
  }
  if (this.includeDeclaration != null) {
    IncludeDeclaration inc=this.includeDeclaration;
    this.includeDeclaration=null;
    inc.resolve(markers);
    if (this.reportErrors(markers)) {
      return;
    }
    this.addIncludeToArray(inc);
    System.out.println("String_Node_Str" + inc.getHeader().getFullName());
    return;
  }
  if (this.importDeclaration == null || this.importDeclaration.theImport == null) {
    return;
  }
  importDeclaration.resolveTypes(markers,this,false);
  if (this.reportErrors(markers)) {
    return;
  }
  boolean isStatic=importDeclaration.isStatic;
  if (isStatic) {
    super.addStaticImport(importDeclaration);
    System.out.println("String_Node_Str" + importDeclaration.theImport);
  }
 else {
    super.addImport(importDeclaration);
    System.out.println("String_Node_Str" + importDeclaration.theImport);
  }
  importDeclaration=null;
}
Program: 84821
Project: 84821
Buggy source:
@Override public void addStaticImport(ImportDeclaration component){
  headerComponent=component;
}

Fixed version (ground truth):
@Override public void addStaticImport(ImportDeclaration component){
  importDeclaration=component;
}
Program: 84822
Project: 84822
Buggy source:
@Override public void addImport(ImportDeclaration component){
  headerComponent=component;
}

Fixed version (ground truth):
@Override public void addImport(ImportDeclaration component){
  importDeclaration=component;
}
Program: 84823
Project: 84823
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 84824
Project: 84824
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 84825
Project: 84825
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 84826
Project: 84826
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.genericData != null) {
    this.genericData.resolveTypes(markers,context);
  }
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.genericData != null) {
    this.genericData.resolveTypes(markers,context);
  }
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 84827
Project: 84827
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 84829
Project: 84829
Buggy source:
private void writeArguments(MethodWriter writer,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    int len=this.parameterCount;
    if ((this.modifiers & Modifiers.VARARGS) != 0) {
      len--;
      IParameter param;
      for (int i=1, j=0; i < len; i++, j++) {
        param=this.parameters[i];
        arguments.writeValue(j,param.getName(),param.getValue(),writer);
      }
      param=this.parameters[len];
      arguments.writeVarargsValue(len - 1,param.getName(),param.getType(),writer);
      return;
    }
    for (int i=1, j=0; i < this.parameterCount; i++, j++) {
      IParameter param=this.parameters[i];
      arguments.writeValue(j,param.getName(),param.getValue(),writer);
    }
    return;
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    arguments.writeValue(0,Name._this,null,writer);
    return;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int len=this.parameterCount - 1;
    IParameter param;
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      arguments.writeValue(i,param.getName(),param.getValue(),writer);
    }
    param=this.parameters[len];
    arguments.writeVarargsValue(len,param.getName(),param.getType(),writer);
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    arguments.writeValue(i,param.getName(),param.getValue(),writer);
  }
}

Fixed version (ground truth):
private void writeArguments(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null && (this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    int len=this.parameterCount;
    if ((this.modifiers & Modifiers.VARARGS) != 0) {
      len--;
      IParameter param;
      for (int i=1, j=0; i < len; i++, j++) {
        param=this.parameters[i];
        arguments.writeValue(j,param.getName(),param.getValue(),writer);
      }
      param=this.parameters[len];
      arguments.writeVarargsValue(len - 1,param.getName(),param.getType(),writer);
      return;
    }
    for (int i=1, j=0; i < this.parameterCount; i++, j++) {
      IParameter param=this.parameters[i];
      arguments.writeValue(j,param.getName(),param.getValue(),writer);
    }
    return;
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    arguments.writeValue(0,Name._this,null,writer);
    return;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int len=this.parameterCount - 1;
    IParameter param;
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      arguments.writeValue(i,param.getName(),param.getValue(),writer);
    }
    param=this.parameters[len];
    arguments.writeVarargsValue(len,param.getName(),param.getType(),writer);
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    arguments.writeValue(i,param.getName(),param.getValue(),writer);
  }
}
Program: 84830
Project: 84830
Buggy source:
private void writeIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(i,dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}

Fixed version (ground truth):
private void writeIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,instance,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(i,dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}
Program: 84831
Project: 84831
Buggy source:
private void writeInvIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(Opcodes.getInverseOpcode(i),dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}

Fixed version (ground truth):
private void writeInvIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,instance,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(Opcodes.getInverseOpcode(i),dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}
Program: 84832
Project: 84832
Buggy source:
private void writeInvoke(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
  }
  this.writeArguments(writer,arguments);
  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.valueTag() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.getDescriptor();
  writer.writeInvokeInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS));
}

Fixed version (ground truth):
private void writeInvoke(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
  }
  this.writeArguments(writer,instance,arguments);
  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.valueTag() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.getDescriptor();
  writer.writeInvokeInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS));
}
Program: 84833
Project: 84833
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    this.value.checkTypes(markers,context);
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  if (!this.typeHint && this.type.isSuperTypeOf(this.value.getType())) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  IValue value1=this.value.withType(this.type);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.value.checkTypes(markers,context);
    this.type=value1.getType();
    return this;
  }
  this.value.checkTypes(markers,context);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    this.value.checkTypes(markers,context);
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  if (!this.typeHint && this.type.equals(this.value.getType())) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  IValue value1=this.value.withType(this.type);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.value.checkTypes(markers,context);
    this.type=value1.getType();
    return this;
  }
  this.value.checkTypes(markers,context);
  return this;
}
Program: 84834
Project: 84834
Buggy source:
@Override public HashMap<K,V> copy(){
  int len=MathUtils.powerOfTwo(this.size);
  HashEntry[] newEntries=new HashEntry[len];
  for (  HashEntry<K,V> e : this.entries) {
    while (e != null) {
      int index=index(e.hash,len);
      HashEntry<K,V> newEntry=new HashEntry(e.key,e.value,e.hash);
      if (newEntries[index] != null) {
        newEntry.next=newEntries[index];
      }
      newEntries[index]=newEntry;
      e=e.next;
    }
  }
  return new HashMap<>(this.size,this.loadFactor,newEntries);
}

Fixed version (ground truth):
@Override public HashMap<K,V> copy(){
  int len=MathUtils.powerOfTwo(this.size + 2);
  HashEntry[] newEntries=new HashEntry[len];
  for (  HashEntry<K,V> e : this.entries) {
    while (e != null) {
      int index=index(e.hash,len);
      HashEntry<K,V> newEntry=new HashEntry(e.key,e.value,e.hash);
      if (newEntries[index] != null) {
        newEntry.next=newEntries[index];
      }
      newEntries[index]=newEntry;
      e=e.next;
    }
  }
  return new HashMap<>(this.size,this.loadFactor,newEntries);
}
Program: 84835
Project: 84835
Buggy source:
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  if (this.instanceField != null) {
    this.instanceField.write(writer);
  }
  super.write(writer,instanceFields);
  if (!this.hasToString) {
    MethodWriterImpl mw=new MethodWriterImpl(writer,writer.visitMethod(Modifiers.PUBLIC,"String_Node_Str","String_Node_Str",null,null));
    mw.begin();
    mw.writeLDC(this.theClass.getName().unqualified);
    mw.writeInsn(Opcodes.ARETURN);
    mw.end(Types.STRING);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  if (this.instanceField != null) {
    this.instanceField.write(writer);
  }
  super.write(writer,instanceFields);
  if (!this.hasToString) {
    MethodWriterImpl mw=new MethodWriterImpl(writer,writer.visitMethod(Modifiers.PUBLIC,"String_Node_Str","String_Node_Str",null,null));
    mw.begin();
    mw.setThisType(this.theClass.getInternalName());
    mw.writeLDC(this.theClass.getName().unqualified);
    mw.writeInsn(Opcodes.ARETURN);
    mw.end(Types.STRING);
  }
}
Program: 84837
Project: 84837
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v1=this.values[i].withType(typeList.getType(i));
      if (v1 != null) {
        this.values[i]=v1;
      }
 else {
      }
      this.values[i].checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,this.position,context,null,this.arguments,null);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IType type=typeList.getType(i);
      IValue value=this.values[i];
      IValue value1=value.withType(type);
      if (value1 == null) {
        Marker m=markers.create(value.getPosition(),"String_Node_Str");
        m.addInfo("String_Node_Str" + value.getType());
        m.addInfo("String_Node_Str" + type);
      }
 else {
        this.values[i]=value=value1;
      }
      value.checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,this.position,context,null,this.arguments,null);
  }
}
Program: 84839
Project: 84839
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  int dims=this.requiredType.getArrayDimensions();
  if (dims > 0) {
    for (int i=0; i < dims; i++) {
      writer.writeLDC(0);
    }
    writer.writeNewArray(this.requiredType,dims);
    return;
  }
  this.method.writeCall(writer,null,EmptyArguments.INSTANCE,this.requiredType);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  if (this.requiredType.isArrayType()) {
    IType elementType=this.requiredType.getElementType();
    if (elementType.isPrimitive()) {
      writer.writeFieldInsn(Opcodes.GETSTATIC,this.requiredType.getTheClass().getInternalName(),"String_Node_Str",this.requiredType.getExtendedName());
      return;
    }
    writer.writeLDC(0);
    int dims=1;
    while (elementType.isArrayType()) {
      elementType=elementType.getElementType();
      dims++;
      writer.writeLDC(0);
    }
    writer.writeNewArray(elementType,dims);
    return;
  }
  this.method.writeCall(writer,null,EmptyArguments.INSTANCE,this.requiredType);
}
Program: 84840
Project: 84840
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.elementType == null) {
    this.getType();
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].checkTypes(markers,context);
    }
  }
  IType type=this.elementType;
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(type);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
    value.checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.elementType == null) {
    if (this.valueCount == 0) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    this.getType();
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].checkTypes(markers,context);
    }
  }
  IType type=this.elementType;
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(type);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
    value.checkTypes(markers,context);
  }
}
Program: 84841
Project: 84841
Buggy source:
@Override public void writeNewArray(IType type,int dims) throws BytecodeException {
  if (dims == 1) {
    if (type.typeTag() == IType.PRIMITIVE_TYPE) {
      this.writeIntInsn(Opcodes.NEWARRAY,((PrimitiveType)type).typecode);
      return;
    }
    this.writeTypeInsn(Opcodes.ANEWARRAY,type.getInternalName());
    return;
  }
  this.insnCallback();
  String extended=type.getExtendedName();
  this.frame.visitNewArray(extended,dims);
  this.mv.visitMultiANewArrayInsn(extended,dims);
}

Fixed version (ground truth):
@Override public void writeNewArray(IType type,int dims) throws BytecodeException {
  if (dims == 1) {
    if (type.typeTag() == IType.PRIMITIVE_TYPE) {
      this.writeIntInsn(Opcodes.NEWARRAY,((PrimitiveType)type).typecode);
      return;
    }
    this.writeTypeInsn(Opcodes.ANEWARRAY,type.getInternalName());
    return;
  }
  this.insnCallback();
  StringBuilder builder=new StringBuilder();
  for (int i=0; i < dims; i++) {
    builder.append('[');
  }
  type.appendExtendedName(builder);
  String extended=builder.toString();
  this.frame.visitNewArray(extended,dims);
  this.mv.visitMultiANewArrayInsn(extended,dims);
}
Program: 84842
Project: 84842
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a statement. That means that this element is removedfrom the stack.
 * @param writer
 * @throws BytecodeException TODO
 */
public void writeStatement(MethodWriter writer) throws BytecodeException ;

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a statement. That means that this element is removedfrom the stack.
 * @param writer
 * @throws BytecodeException
 */
public void writeStatement(MethodWriter writer) throws BytecodeException ;
Program: 84843
Project: 84843
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a jump expression to the given {@link Label}{@code dest}. By default, this calls  {@link #writeExpression(MethodWriter)} and then writes an{@link Opcodes#IFEQ IFEQ} instruction pointing to {@code dest}. That means the JVM would jump to   {@code dest} if the current value on thestack equals  {@code 0}.
 * @param writer
 * @param dest
 * @throws BytecodeException TODO
 */
public default void writeInvJump(MethodWriter writer,Label dest) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeJumpInsn(Opcodes.IFEQ,dest);
}

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a jump expression to the given {@link Label}{@code dest}. By default, this calls  {@link #writeExpression(MethodWriter)} and then writes an{@link Opcodes#IFEQ IFEQ} instruction pointing to {@code dest}. That means the JVM would jump to   {@code dest} if the current value on thestack equals  {@code 0}.
 * @param writer
 * @param dest
 * @throws BytecodeException
 */
public default void writeInvJump(MethodWriter writer,Label dest) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeJumpInsn(Opcodes.IFEQ,dest);
}
Program: 84844
Project: 84844
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as an expression. That means that this element remains asthe first element of the stack.
 * @param visitor
 * @throws BytecodeException TODO
 */
public void writeExpression(MethodWriter writer) throws BytecodeException ;

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as an expression. That means that this element remains asthe first element of the stack.
 * @param visitor
 * @throws BytecodeException
 */
public void writeExpression(MethodWriter writer) throws BytecodeException ;
Program: 84845
Project: 84845
Buggy source:
@Override public NestedClass getInnerClass(int index){
  return null;
}

Fixed version (ground truth):
@Override public IClassCompilable getInnerClass(int index){
  return null;
}
Program: 84846
Project: 84846
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
}
Program: 84847
Project: 84847
Buggy source:
@Override public NestedClass getInnerClass(int index){
  return this.innerClasses[index];
}

Fixed version (ground truth):
@Override public IClassCompilable getInnerClass(int index){
  return this.innerClasses[index];
}
Program: 84849
Project: 84849
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
  int index=this.innerClassCount++;
  if (index >= this.innerClasses.length) {
    NestedClass[] temp=new NestedClass[this.innerClassCount];
    System.arraycopy(this.innerClasses,0,temp,0,this.innerClasses.length);
    this.innerClasses=temp;
  }
  this.innerClasses[index]=iclass;
  iclass.setIndex(index);
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
  int index=this.innerClassCount++;
  if (index >= this.innerClasses.length) {
    IClassCompilable[] temp=new IClassCompilable[this.innerClassCount];
    System.arraycopy(this.innerClasses,0,temp,0,this.innerClasses.length);
    this.innerClasses=temp;
  }
  this.innerClasses[index]=iclass;
  iclass.setInnerIndex(index);
}
Program: 84850
Project: 84850
Buggy source:
public NestedClass getInnerClass(int index);

Fixed version (ground truth):
public IClassCompilable getInnerClass(int index);
Program: 84851
Project: 84851
Buggy source:
public void addInnerClass(NestedClass iclass);

Fixed version (ground truth):
public void addInnerClass(IClassCompilable iclass);
Program: 84852
Project: 84852
Buggy source:
@Override public final IType getReferenceType(){
  Type type=new Type(this.position,this.theClass);
  type.name=this.name;
  return type;
}

Fixed version (ground truth):
@Override public final IType getReferenceType(){
  Type type=new Type(this.position,this.theClass);
  if (this != Types.VOID) {
    type.name=this.name;
  }
  return type;
}