nus-yam/ex-repair huggingface dataset:
Program: 83140
Project: 83140
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount == 1) {
    return this.values[0].withType(type,typeContext,markers,context);
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralExpression(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  IClass tupleClass=TupleType.getTupleClass(this.valueCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  for (int i=0; i < this.valueCount; i++) {
    IType elementType=type.resolveType(tupleClass.getTypeVariable(i));
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker m=markers.create(value.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + value.getType());
      m.addInfo("String_Node_Str" + elementType);
    }
 else {
      this.values[i]=value=value1;
    }
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount == 1) {
    return this.values[0].withType(type,typeContext,markers,context);
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralExpression(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  IClass tupleClass=TupleType.getTupleClass(this.valueCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  this.tupleType=type;
  for (int i=0; i < this.valueCount; i++) {
    IType elementType=type.resolveTypeSafely(tupleClass.getTypeVariable(i));
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker m=markers.create(value.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + value.getType());
      m.addInfo("String_Node_Str" + elementType);
    }
 else {
      this.values[i]=value=value1;
    }
  }
  return this;
}
Program: 83141
Project: 83141
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.value.writeExpression(writer,this.type);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.value.writeExpression(writer);
  this.value.getType().writeCast(writer,this.type,this.getLineNumber());
}
Program: 83142
Project: 83142
Buggy source:
@Override public IPattern withType(IType type,MarkerList markers){
  IClass tupleClass=TupleType.getTupleClass(this.patternCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  this.tupleType=type;
  for (int i=0; i < this.patternCount; i++) {
    IType type1=type.resolveType(tupleClass.getTypeVariable(i));
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type1,markers);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type1);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
  return this;
}

Fixed version (ground truth):
@Override public IPattern withType(IType type,MarkerList markers){
  IClass tupleClass=TupleType.getTupleClass(this.patternCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  this.tupleType=type;
  for (int i=0; i < this.patternCount; i++) {
    IType type1=type.resolveTypeSafely(tupleClass.getTypeVariable(i));
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type1,markers);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type1);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
  return this;
}
Program: 83143
Project: 83143
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.then == null) {
    this.condition.writeExpression(writer);
    writer.writeInsn(Opcodes.POP);
    return;
  }
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  if (this.elseThen != null) {
    dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
    this.condition.writeInvJump(writer,elseStart);
    this.then.writeStatement(writer);
    writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
    writer.writeLabel(elseStart);
    this.elseThen.writeStatement(writer);
    writer.writeLabel(elseEnd);
  }
 else {
    this.condition.writeInvJump(writer,elseStart);
    this.then.writeStatement(writer);
    writer.writeLabel(elseStart);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.then == null) {
    this.condition.writeExpression(writer);
    writer.writeInsn(Opcodes.POP);
    return;
  }
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  if (this.elseThen != null) {
    dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
    this.condition.writeInvJump(writer,elseStart);
    this.then.writeStatement(writer);
    writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
    writer.writeTargetLabel(elseStart);
    this.elseThen.writeStatement(writer);
    writer.writeTargetLabel(elseEnd);
  }
 else {
    this.condition.writeInvJump(writer,elseStart);
    this.then.writeStatement(writer);
    writer.writeTargetLabel(elseStart);
  }
}
Program: 83144
Project: 83144
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
  Object commonFrameType=this.commonType.getFrameType();
  this.condition.writeInvJump(writer,elseStart);
  this.then.writeExpression(writer,this.commonType);
  writer.getFrame().set(commonFrameType);
  writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
  writer.writeLabel(elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer,this.commonType);
  }
  writer.getFrame().set(commonFrameType);
  writer.writeLabel(elseEnd);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
  Object commonFrameType=this.commonType.getFrameType();
  this.condition.writeInvJump(writer,elseStart);
  this.then.writeExpression(writer,this.commonType);
  writer.getFrame().set(commonFrameType);
  writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
  writer.writeTargetLabel(elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer,this.commonType);
  }
  writer.getFrame().set(commonFrameType);
  writer.writeTargetLabel(elseEnd);
}
Program: 83147
Project: 83147
Buggy source:
@Override default boolean isGenericType(){
  return false;
}

Fixed version (ground truth):
@Override public default boolean isGenericType(){
  return false;
}
Program: 83148
Project: 83148
Buggy source:
public default int getTypecode(){
  return -1;
}

Fixed version (ground truth):
public int getTypecode();
Program: 83149
Project: 83149
Buggy source:
public default boolean isPrimitive(){
  return false;
}

Fixed version (ground truth):
public boolean isPrimitive();
Program: 83150
Project: 83150
Buggy source:
@Override public void inferTypes(IType concrete,ITypeContext typeContext){
  IClass iclass=getTupleClass(this.typeCount);
  for (int i=0; i < this.typeCount; i++) {
    ITypeVariable typeVar=iclass.getTypeVariable(i);
    IType concreteType=concrete.resolveType(typeVar);
    if (concreteType != null) {
      this.types[i].inferTypes(concreteType,typeContext);
    }
  }
}

Fixed version (ground truth):
@Override public void inferTypes(IType concrete,ITypeContext typeContext){
  IClass iclass=getTupleClass(this.typeCount);
  for (int i=0; i < this.typeCount; i++) {
    ITypeVariable typeVar=iclass.getTypeVariable(i);
    IType concreteType=concrete.resolveTypeSafely(typeVar);
    if (concreteType != null) {
      this.types[i].inferTypes(concreteType,typeContext);
    }
  }
}
Program: 83151
Project: 83151
Buggy source:
@Override public IMethod getFunctionalMethod(){
  if (this.functionalMethod != null) {
    return this.functionalMethod;
  }
  for (int i=0; i < this.methodCount; i++) {
    IMethod m=this.methods[i];
    if (m.hasModifier(Modifiers.ABSTRACT)) {
      this.functionalMethod=m;
      return m;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IMethod getFunctionalMethod(){
  if (this.functionalMethod != null) {
    return this.functionalMethod;
  }
  boolean found=false;
  IMethod match=null;
  for (int i=0; i < this.methodCount; i++) {
    IMethod m=this.methods[i];
    if (m.hasModifier(Modifiers.ABSTRACT)) {
      if (found) {
        return null;
      }
      found=true;
      match=m;
    }
  }
  return this.functionalMethod=match;
}
Program: 83152
Project: 83152
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,new CombiningContext(this,context));
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.method == null) {
    IType type=this.getType();
    this.withType(type,type,markers,context);
  }
  this.value.checkTypes(markers,new CombiningContext(this,context));
}
Program: 83153
Project: 83153
Buggy source:
@Override public float getVarargsTypeMatch(int index,IParameter param){
  if (index == this.size) {
    return DEFAULT_MATCH;
  }
  if (index > this.size) {
    return 0;
  }
  IValue argument=this.values[index];
  IType type=param.getType();
  float m=argument.getTypeMatch(type);
  if (m != 0) {
    return m;
  }
  return argument.getTypeMatch(type.getElementType());
}

Fixed version (ground truth):
@Override public float getVarargsTypeMatch(int index,IParameter param){
  if (index == this.size) {
    return DEFAULT_MATCH;
  }
  if (index > this.size) {
    return 0;
  }
  IValue argument=this.values[index];
  IType type=param.getType();
  float m=argument.getTypeMatch(type);
  if (m > 0F) {
    return m;
  }
  return argument.getTypeMatch(type.getElementType());
}
Program: 83154
Project: 83154
Buggy source:
public default int getSubClassDistance(IType subtype){
  if (subtype.isArrayType()) {
    IClass iclass=this.getTheClass();
    if (iclass == Types.OBJECT_CLASS) {
      return 3;
    }
    return 0;
  }
  return subtype.getTheClass().getSuperTypeDistance(this);
}

Fixed version (ground truth):
public default int getSubClassDistance(IType subtype){
  return subtype.getSuperTypeDistance(this);
}
Program: 83155
Project: 83155
Buggy source:
public default float getSubTypeDistance(IType subtype){
  if (subtype.isArrayType()) {
    IClass iclass=this.getTheClass();
    if (iclass == Types.OBJECT_CLASS) {
      return 3F;
    }
    return 0F;
  }
  return subtype.getTheClass().getSuperTypeDistance(this);
}

Fixed version (ground truth):
public default float getSubTypeDistance(IType subtype){
  return subtype.getSuperTypeDistance(this);
}
Program: 83156
Project: 83156
Buggy source:
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  if (this.capturedFieldCount == 0) {
    if (this.value instanceof AbstractCall) {
      AbstractCall c=(AbstractCall)this.value;
      IMethod method=c.getMethod();
      if (this.checkCall(c.getValue(),c.getArguments(),method)) {
switch (method.getInvokeOpcode()) {
case Opcodes.INVOKEVIRTUAL:
          this.directInvokeOpcode=ClassFormat.H_INVOKEVIRTUAL;
        break;
case Opcodes.INVOKESTATIC:
      this.directInvokeOpcode=ClassFormat.H_INVOKESTATIC;
    break;
case Opcodes.INVOKEINTERFACE:
  this.directInvokeOpcode=ClassFormat.H_INVOKEINTERFACE;
break;
case Opcodes.INVOKESPECIAL:
this.directInvokeOpcode=ClassFormat.H_INVOKESPECIAL;
break;
}
this.name=method.getName().qualified;
this.owner=method.getTheClass().getInternalName();
return this;
}
}
 else if (this.value.getClass() == ConstructorCall.class) {
ConstructorCall c=(ConstructorCall)this.value;
IConstructor ctor=c.getConstructor();
if (this.checkCall(null,c.getArguments(),ctor)) {
this.directInvokeOpcode=ClassFormat.H_NEWINVOKESPECIAL;
this.name="String_Node_Str";
this.owner=ctor.getTheClass().getInternalName();
return this;
}
}
}
compilableList.addCompilable(this);
return this;
}

Fixed version (ground truth):
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  if (this.capturedFieldCount == 0) {
    if (this.value instanceof AbstractCall) {
      AbstractCall c=(AbstractCall)this.value;
      IMethod method=c.getMethod();
      if (this.checkCall(c.getValue(),c.getArguments(),method)) {
switch (method.getInvokeOpcode()) {
case Opcodes.INVOKEVIRTUAL:
          this.directInvokeOpcode=ClassFormat.H_INVOKEVIRTUAL;
        break;
case Opcodes.INVOKESTATIC:
      this.directInvokeOpcode=ClassFormat.H_INVOKESTATIC;
    break;
case Opcodes.INVOKEINTERFACE:
  this.directInvokeOpcode=ClassFormat.H_INVOKEINTERFACE;
break;
case Opcodes.INVOKESPECIAL:
this.directInvokeOpcode=ClassFormat.H_INVOKESPECIAL;
break;
}
this.name=method.getName().qualified;
this.owner=method.getTheClass().getInternalName();
this.lambdaDesc=method.getDescriptor();
return this;
}
}
 else if (this.value.getClass() == ConstructorCall.class) {
ConstructorCall c=(ConstructorCall)this.value;
IConstructor ctor=c.getConstructor();
if (this.checkCall(null,c.getArguments(),ctor)) {
this.directInvokeOpcode=ClassFormat.H_NEWINVOKESPECIAL;
this.name="String_Node_Str";
this.owner=ctor.getTheClass().getInternalName();
this.lambdaDesc=ctor.getDescriptor();
return this;
}
}
}
compilableList.addCompilable(this);
return this;
}
Program: 83157
Project: 83157
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
 else       if (instance.getType().getTheClass() != this.theClass) {
        markers.add(position,"String_Node_Str",this.name.unqualified,this.theClass.getFullName());
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (IContext.getVisibility(context,this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
 else       if (instance.getType().getTheClass() != this.theClass) {
        markers.add(position,"String_Node_Str",this.name.unqualified,this.theClass.getFullName());
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
 else {
      IType type=this.theClass.getType();
      instance=type.convertValue(instance,type,markers,context);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (IContext.getVisibility(context,this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}
Program: 83158
Project: 83158
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
 else       if (instance.getType().getTheClass() != this.theClass) {
        markers.add(position,"String_Node_Str",this.name.unqualified,this.theClass.getFullName());
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
 else       if (instance.getType().getTheClass() != this.theClass) {
        markers.add(position,"String_Node_Str",this.name.unqualified,this.theClass.getFullName());
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
 else {
      IType type=this.theClass.getType();
      instance=type.convertValue(instance,type,markers,context);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}
Program: 83160
Project: 83160
Buggy source:
@Override public float getTypeMatch(IType type){
  return this.isType(type) ? 1 : 0;
}

Fixed version (ground truth):
@Override public float getTypeMatch(IType type){
  if (type.getTheClass() == Types.OBJECT_CLASS) {
    return 2;
  }
  return this.isType(type) ? 1 : 0;
}
Program: 83162
Project: 83162
Buggy source:
public static <E>ImmutableList<E> apply(E... elements){
  return new ArrayList(elements,true);
}

Fixed version (ground truth):
public static <E>ImmutableList<E> apply(int count,IntFunction<E> generator){
  Object[] elements=new Object[count];
  for (int i=0; i < count; i++) {
    elements[i]=generator.apply(i);
  }
  return new ArrayList(elements,count,true);
}
Program: 83163
Project: 83163
Buggy source:
/** 
 * Returns an immutable list containing all of the given   {@code elements}. This method is primarily for use with <i>Array Expressions</i> in <i>Dyvil</i> and internally creates an  {@link dyvil.collection.immutable.ArrayList ArrayList} from the given{@code elements}.
 * @param elements the elements of the returned collection
 * @return an immutable list containing all of the given elements
 */
public static <E>ImmutableList<E> apply(E... elements){
  return ImmutableList.apply(elements);
}

Fixed version (ground truth):
public static <E>ImmutableList<E> apply(int count,IntFunction<E> generator){
  return ImmutableList.apply(count,generator);
}
Program: 83164
Project: 83164
Buggy source:
/** 
 * @return the descriptor of the (synthetic) lambda callback method,including captured variables, parameter types and the return type.
 */
private String getLambdaDescriptor(){
  if (this.lambdaDesc != null) {
    return this.lambdaDesc;
  }
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  for (int i=0; i < this.capturedFieldCount; i++) {
    this.capturedFields[i].getActualType().appendExtendedName(buffer);
  }
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  if (this.directInvokeOpcode == ClassFormat.H_NEWINVOKESPECIAL) {
    buffer.append('V');
  }
 else {
    this.returnType.appendExtendedName(buffer);
  }
  return this.lambdaDesc=buffer.toString();
}

Fixed version (ground truth):
/** 
 * @return the descriptor of the (synthetic) lambda callback method,including captured variables, parameter types and the return type.
 */
private String getLambdaDescriptor(){
  if (this.lambdaDesc != null) {
    return this.lambdaDesc;
  }
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  for (int i=0; i < this.capturedFieldCount; i++) {
    this.capturedFields[i].getActualType().appendExtendedName(buffer);
  }
  for (int i=this.directInvokeOpcode != 0 && this.directInvokeOpcode != Opcodes.INVOKESTATIC ? 1 : 0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  if (this.directInvokeOpcode == ClassFormat.H_NEWINVOKESPECIAL) {
    buffer.append('V');
  }
 else {
    this.returnType.appendExtendedName(buffer);
  }
  return this.lambdaDesc=buffer.toString();
}
Program: 83165
Project: 83165
Buggy source:
private boolean checkCall(IValue instance,IArguments arguments,IParameterized p){
  this.value=null;
  if (instance != null) {
    if (this.parameterCount <= 0) {
      return false;
    }
    if (isFieldAccess(instance,this.parameters[0])) {
      if (arguments.size() != this.parameterCount - 1) {
        return false;
      }
      for (int i=1; i < this.parameterCount; i++) {
        IValue v=arguments.getValue(i - 1,p.getParameter(i - 1));
        if (!isFieldAccess(v,this.parameters[i])) {
          return false;
        }
      }
    }
    this.value=instance;
    this.thisClass=instance.getType().getTheClass();
  }
  if (arguments.size() != this.parameterCount) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IValue v=arguments.getValue(i,p.getParameter(i));
    if (!isFieldAccess(v,this.parameters[i])) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
private boolean checkCall(IValue instance,IArguments arguments,IParameterized p){
  boolean receiver=false;
  if (instance != null) {
    if (instance.isPrimitive()) {
      return false;
    }
    if (this.parameterCount <= 0) {
      return false;
    }
    if (isFieldAccess(instance,this.parameters[0])) {
      if (arguments.size() != this.parameterCount - 1) {
        return false;
      }
      for (int i=1; i < this.parameterCount; i++) {
        IValue v=arguments.getValue(i - 1,p.getParameter(i - 1));
        if (!isFieldAccess(v,this.parameters[i])) {
          return false;
        }
      }
      this.value=null;
      return true;
    }
    receiver=true;
  }
  if (arguments.size() != this.parameterCount) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IValue v=arguments.getValue(i,p.getParameter(i));
    if (!isFieldAccess(v,this.parameters[i])) {
      return false;
    }
  }
  if (receiver) {
    if (instance.isPrimitive()) {
      return false;
    }
    this.value=instance;
    this.thisClass=instance.getType().getTheClass();
  }
 else {
    this.value=null;
  }
  return true;
}
Program: 83166
Project: 83166
Buggy source:
@Override public int getInvokeOpcode(){
  if ((modifiers & Modifiers.STATIC) != 0) {
    return Opcodes.INVOKESTATIC;
  }
  if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    return Opcodes.INVOKESPECIAL;
  }
  if (this.theClass.isInterface() && (this.modifiers & Modifiers.ABSTRACT) != 0) {
    return Opcodes.INVOKEINTERFACE;
  }
  return Opcodes.INVOKEVIRTUAL;
}

Fixed version (ground truth):
@Override public int getInvokeOpcode(){
  if ((modifiers & Modifiers.STATIC) != 0) {
    return Opcodes.INVOKESTATIC;
  }
  if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    return Opcodes.INVOKESPECIAL;
  }
  if (this.theClass.isInterface()) {
    return Opcodes.INVOKEINTERFACE;
  }
  return Opcodes.INVOKEVIRTUAL;
}
Program: 83167
Project: 83167
Buggy source:
private void inferTypes(MarkerList markers){
  if (!this.method.hasTypeVariables()) {
    for (int i=0; i < this.parameterCount; i++) {
      IParameter param=this.parameters[i];
      if (param.getType() == Types.UNKNOWN) {
        param.setType(this.method.getParameter(i).getType());
      }
    }
    this.returnType=this.method.getType();
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    IType parType=param.getType();
    if (parType != Types.UNKNOWN) {
      continue;
    }
    IType methodParamType=this.method.getParameter(i).getType();
    IType concreteType=methodParamType.getConcreteType(this.type).getParameterType();
    if (concreteType == methodParamType && concreteType.hasTypeVariables()) {
      markers.add(param.getPosition(),"String_Node_Str",param.getName());
    }
    param.setType(concreteType);
  }
  this.returnType=this.method.getType().getConcreteType(this.type).getReturnType();
  return;
}

Fixed version (ground truth):
private void inferTypes(MarkerList markers){
  if (!this.method.hasTypeVariables()) {
    for (int i=0; i < this.parameterCount; i++) {
      IParameter param=this.parameters[i];
      if (param.getType() == Types.UNKNOWN) {
        param.setType(this.method.getParameter(i).getType());
      }
    }
    this.returnType=this.method.getType();
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    if (param.getType() != Types.UNKNOWN) {
      continue;
    }
    IType methodParamType=this.method.getParameter(i).getType();
    IType concreteType=methodParamType.getConcreteType(this.type).getParameterType();
    if (concreteType == Types.UNKNOWN) {
      markers.add(param.getPosition(),"String_Node_Str",param.getName());
    }
    param.setType(concreteType);
  }
  this.returnType=this.method.getType().getConcreteType(this.type).getReturnType();
  return;
}
Program: 83168
Project: 83168
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass != null) {
    if (iclass.hasModifier(Modifiers.DEPRECATED)) {
      markers.add(this.position,"String_Node_Str",iclass.getName());
    }
    if (context.getThisClass().getVisibility(iclass) == IContext.SEALED) {
      markers.add(this.position,"String_Node_Str",iclass.getName());
    }
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass != null) {
    if (iclass.hasModifier(Modifiers.DEPRECATED)) {
      markers.add(this.position,"String_Node_Str",iclass.getName());
    }
    if (context.getThisClass().getVisibility(iclass) == IContext.INTERNAL) {
      markers.add(this.position,"String_Node_Str",iclass.getName());
    }
  }
}
Program: 83169
Project: 83169
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.SEALED:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}
Program: 83170
Project: 83170
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.SEALED:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
      instance=null;
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      if (!instance.getType().getTheClass().isObject()) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
      }
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      instance=new ThisValue(position,this.theClass.getType(),context,markers);
    }
  }
  if (this.hasModifier(Modifiers.DEPRECATED)) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
return instance;
}
Program: 83171
Project: 83171
Buggy source:
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.theClass.getName());
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.SEALED:
    markers.add(position,"String_Node_Str",this.theClass.getName());
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.theClass.getName());
break;
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}

Fixed version (ground truth):
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.theClass.getName());
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.theClass.getName());
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.theClass.getName());
break;
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}
Program: 83172
Project: 83172
Buggy source:
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.SEALED:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
if ((this.modifiers & Modifiers.PREFIX) != 0) {
IValue value=arguments.getFirstValue();
this.checkMutating(markers,value != null ? value : instance);
}
 else if (instance != null) {
this.checkMutating(markers,instance);
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}

Fixed version (ground truth):
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getThisClass().getVisibility(this)) {
case IContext.INTERNAL:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
if ((this.modifiers & Modifiers.PREFIX) != 0) {
IValue value=arguments.getFirstValue();
this.checkMutating(markers,value != null ? value : instance);
}
 else if (instance != null) {
this.checkMutating(markers,instance);
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}
Program: 83173
Project: 83173
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (!this.isType(type)) {
    return null;
  }
  if (type.getTheClass() == Types.OBJECT_CLASS) {
    type=this.getType();
  }
  this.type=type;
  this.method=type.getFunctionalMethod();
  if (this.method != null) {
    this.inferTypes(markers);
    IContext context1=new CombiningContext(this,context);
    this.value=this.value.resolve(markers,context1);
    IType valueType=this.value.getType();
    IValue value1=this.value.withType(this.returnType,this.returnType,markers,context1);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.returnType);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      valueType=this.value.getType();
    }
    ITypeContext tempContext=new MapTypeContext();
    this.method.getType().inferTypes(valueType,tempContext);
    IType type1=this.method.getTheClass().getType().getConcreteType(tempContext);
    type.inferTypes(type1,typeContext);
    this.returnType=valueType;
  }
  if (this.type.typeTag() == IType.LAMBDA) {
    this.type=this.getType();
  }
 else {
    this.type=type.getConcreteType(typeContext);
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (!this.isType(type)) {
    return null;
  }
  if (type.getTheClass() == Types.OBJECT_CLASS) {
    type=this.getType();
  }
  this.type=type;
  this.method=type.getFunctionalMethod();
  if (this.method != null) {
    this.inferTypes(markers);
    IContext context1=new CombiningContext(this,context);
    this.value=this.value.resolve(markers,context1);
    IType valueType=this.value.getType();
    IValue value1=this.value.withType(this.returnType,this.returnType,markers,context1);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.returnType);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      valueType=this.value.getType();
    }
    ITypeContext tempContext=new MapTypeContext();
    this.method.getType().inferTypes(valueType,tempContext);
    IType type1=this.method.getTheClass().getType().getConcreteType(tempContext);
    type.inferTypes(type1,typeContext);
    this.returnType=valueType;
  }
  if (this.type.typeTag() == IType.LAMBDA) {
    this.type=null;
    this.type=this.getType();
  }
 else {
    this.type=type.getConcreteType(typeContext);
  }
  return this;
}
Program: 83174
Project: 83174
Buggy source:
public static @infix boolean write(File file,byte[] bytes){
  try {
    if (!file.exists()) {
      file.createNewFile();
    }
    Files.write(file.toPath(),bytes);
    return true;
  }
 catch (  IOException ex) {
    ex.printStackTrace();
    return false;
  }
}

Fixed version (ground truth):
public static @infix boolean write(File file,byte[] bytes){
  File parent=file.getParentFile();
  if (!parent.exists()) {
    parent.mkdirs();
  }
  try {
    if (!file.exists()) {
      file.createNewFile();
    }
    Files.write(file.toPath(),bytes);
    return true;
  }
 catch (  IOException ex) {
    ex.printStackTrace();
    return false;
  }
}
Program: 83176
Project: 83176
Buggy source:
static void unbox(MethodVisitor mv,String sname,Wrapper wt){
  if (sname == DYVIL_LANG_NUMBER) {
    mv.visitMethodInsn(Opcodes.INVOKEINTERFACE,sname,unboxMethod(wt),unboxingDescriptor(wt),true);
    return;
  }
  mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,sname,unboxMethod(wt),unboxingDescriptor(wt),false);
}

Fixed version (ground truth):
static void unbox(MethodVisitor mv,String sname,Wrapper wt){
  mv.visitMethodInsn(Opcodes.INVOKESTATIC,sname,NAME_UNBOX_METHOD,unboxingDescriptor(wt),false);
}
Program: 83177
Project: 83177
Buggy source:
private static String unboxingDescriptor(Wrapper w){
  return "String_Node_Str" + w.basicTypeChar();
}

Fixed version (ground truth):
private static String unboxingDescriptor(Wrapper w){
  return "String_Node_Str" + w.wrapperSimpleName() + "String_Node_Str"+ w.basicTypeChar();
}
Program: 83178
Project: 83178
Buggy source:
private static String boxingDescriptor(Wrapper w){
  return String.format("String_Node_Str",w.basicTypeChar(),wrapperName(w));
}

Fixed version (ground truth):
private static String boxingDescriptor(Wrapper w){
  return "String_Node_Str" + w.basicTypeChar() + "String_Node_Str"+ w.wrapperSimpleName()+ "String_Node_Str";
}
Program: 83179
Project: 83179
Buggy source:
@Override public IDataMember capture(IVariable variable){
  IDataMember member=this.context2.capture(variable);
  if (member == null) {
    return this.context1.capture(variable);
  }
  if (member instanceof IVariable) {
    return this.context1.capture((IVariable)member);
  }
  return member;
}

Fixed version (ground truth):
@Override public IDataMember capture(IVariable variable){
  return this.context1.capture(variable);
}
Program: 83181
Project: 83181
Buggy source:
@Override public IValue convertValue(IValue value,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.parameterCount != 0 || IType.super.isSuperTypeOf(value.getType())) {
    return value.withType(this,typeContext,markers,context);
  }
  IValue value1=value.withType(this.returnType,typeContext,markers,context);
  if (value1 != null) {
    LambdaExpression le=new LambdaExpression(value1.getPosition(),null,0);
    le.setMethod(this.getFunctionalMethod());
    le.setReturnType(this.returnType);
    le.setValue(value1);
    le.setType(this);
    return le;
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue convertValue(IValue value,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.parameterCount != 0 || IType.super.isSuperTypeOf(value.getType())) {
    return value.withType(this,typeContext,markers,context);
  }
  IValue value1=value.withType(this.returnType.getConcreteType(typeContext),typeContext,markers,context);
  if (value1 != null) {
    LambdaExpression le=new LambdaExpression(value1.getPosition(),null,0);
    le.setMethod(this.getFunctionalMethod());
    le.setReturnType(this.returnType);
    le.setValue(value1);
    le.setType(this);
    return le;
  }
  return null;
}
Program: 83183
Project: 83183
Buggy source:
@Override public void setHeader(IDyvilHeader unit){
  this.unit=unit;
}

Fixed version (ground truth):
@Override public void setHeader(IDyvilHeader unit){
  this.unit=unit;
  if (this.name != null) {
    this.internalName=unit.getInternalName(this.name);
    this.fullName=unit.getFullName(this.name);
  }
}
Program: 83184
Project: 83184
Buggy source:
public static <T>void prettyPrint(T value,Class<T> type,StringBuilder builder,boolean fieldNames){
  Field[] fields=type.getFields();
  builder.append(type.getName());
  builder.append('(');
  for (  Field f : fields) {
    if (fieldNames) {
      builder.append(f.getName()).append("String_Node_Str");
    }
    try {
      f.setAccessible(true);
      builder.append(f.get(value));
    }
 catch (    IllegalArgumentException|IllegalAccessException ex) {
      ex.printStackTrace();
    }
  }
  builder.append(')');
}

Fixed version (ground truth):
public static <T>void prettyPrint(T value,Class<T> type,StringBuilder builder,boolean fieldNames){
  Field[] fields=type.getFields();
  builder.append(type.getName());
  builder.append('(');
  int count=0;
  for (  Field f : fields) {
    if ((f.getModifiers() & Modifiers.STATIC) != 0) {
      continue;
    }
    if (count++ > 0) {
      builder.append("String_Node_Str");
    }
    if (fieldNames) {
      builder.append(f.getName()).append("String_Node_Str");
    }
    try {
      f.setAccessible(true);
      builder.append(f.get(value));
    }
 catch (    IllegalArgumentException|IllegalAccessException ex) {
      ex.printStackTrace();
      builder.append("String_Node_Str");
    }
  }
  builder.append(')');
}
Program: 83185
Project: 83185
Buggy source:
@Override public String getFullName(Name name){
  return name.qualified;
}

Fixed version (ground truth):
@Override public String getFullName(Name name){
  return "String_Node_Str" + name.qualified;
}
Program: 83186
Project: 83186
Buggy source:
@Override public void addClass(IClass iclass){
  iclass.resolveTypes(markers,this);
  iclass.resolve(markers,this);
  iclass.checkTypes(markers,this);
  iclass.check(markers,this);
  if (reportErrors(markers)) {
    return;
  }
  iclass.foldConstants();
  iclass.cleanup(this,this);
  REPLContext.compileClass(iclass);
  classes.put(iclass.getName(),iclass);
  System.out.println("String_Node_Str" + iclass.getName());
}

Fixed version (ground truth):
@Override public void addClass(IClass iclass){
  iclass.setHeader(this);
  iclass.resolveTypes(markers,this);
  iclass.resolve(markers,this);
  iclass.checkTypes(markers,this);
  iclass.check(markers,this);
  if (reportErrors(markers)) {
    return;
  }
  iclass.foldConstants();
  iclass.cleanup(this,this);
  REPLContext.compileClass(iclass);
  classes.put(iclass.getName(),iclass);
  System.out.println("String_Node_Str" + iclass.getName());
}
Program: 83187
Project: 83187
Buggy source:
@Override public String getInternalName(Name name){
  return name.qualified;
}

Fixed version (ground truth):
@Override public String getInternalName(Name name){
  return "String_Node_Str" + name.qualified;
}
Program: 83188
Project: 83188
Buggy source:
public static Class compile(IClass iclass){
  try {
    ClassWriter cw=new ClassWriter(DyvilCompiler.asmVersion);
    iclass.write(cw);
    cw.visitEnd();
    byte[] bytes=cw.toByteArray();
    return loadClass(iclass.getName().qualified,bytes);
  }
 catch (  Throwable t) {
    t.printStackTrace();
    return null;
  }
}

Fixed version (ground truth):
public static Class compile(IClass iclass){
  try {
    ClassWriter cw=new ClassWriter(DyvilCompiler.asmVersion);
    iclass.write(cw);
    cw.visitEnd();
    byte[] bytes=cw.toByteArray();
    return loadClass(iclass.getFullName(),bytes);
  }
 catch (  Throwable t) {
    t.printStackTrace();
    return null;
  }
}