nus-yam/ex-repair huggingface dataset:
Program: 84854
Project: 84854
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
  this.tempClass=iclass;
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
}
Program: 84855
Project: 84855
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 84856
Project: 84856
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
    int valueTag=this.instance.valueTag();
    if (valueTag == APPLY_METHOD_CALL) {
      ApplyMethodCall call=(ApplyMethodCall)this.instance;
      IValue instance1=call.instance;
      IArguments arguments1=call.arguments.addLastValue(call);
      IType type=instance1.getType();
      IMethod match=IContext.resolveMethod(type,instance1,Name.update,arguments1);
      if (match != null) {
        this.updateMethod=match;
      }
 else {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
      }
    }
 else     if (valueTag == FIELD_ACCESS) {
      FieldAccess fa=(FieldAccess)this.instance;
      if (fa.field != null) {
        fa.field.checkAssign(markers,this.instance.getPosition(),this.instance,this);
      }
    }
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
    int valueTag=this.instance.valueTag();
    if (valueTag == APPLY_METHOD_CALL) {
      ApplyMethodCall call=(ApplyMethodCall)this.instance;
      IValue instance1=call.instance;
      IArguments arguments1=call.arguments.addLastValue(call);
      IType type=instance1.getType();
      IMethod match=IContext.resolveMethod(type,instance1,Name.update,arguments1);
      if (match != null) {
        this.updateMethod=match;
      }
 else {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
      }
    }
 else     if (valueTag == FIELD_ACCESS) {
      FieldAccess fa=(FieldAccess)this.instance;
      if (fa.field != null) {
        fa.field.checkAssign(markers,this.instance.getPosition(),this.instance,this);
      }
    }
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 84857
Project: 84857
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.constructor != null) {
    this.constructor.checkArguments(markers,this.arguments);
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.constructor != null) {
    this.constructor.checkArguments(markers,this.position,context,this.arguments);
  }
  this.arguments.checkTypes(markers,context);
}
Program: 84858
Project: 84858
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance,context);
  }
}
Program: 84859
Project: 84859
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance);
    this.value=this.field.checkAssign(markers,this.position,this.instance,this.value);
  }
  this.value.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance,context);
    this.value=this.field.checkAssign(markers,this.position,this.instance,this.value);
  }
  this.value.checkTypes(markers,context);
}
Program: 84860
Project: 84860
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 84861
Project: 84861
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}
Program: 84862
Project: 84862
Buggy source:
@Override public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext){
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  return instance;
}
Program: 84863
Project: 84863
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(this.type,null,Name.apply,this.arguments);
  if (match == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
  }
 else {
    this.method=match;
    GenericData data=match.getGenericData(null,null,this.arguments);
    match.checkArguments(markers,null,this.arguments,data);
    this.type=match.getType().getConcreteType(data);
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(this.type,null,Name.apply,this.arguments);
  if (match == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
  }
 else {
    this.method=match;
    GenericData data=match.getGenericData(null,null,this.arguments);
    match.checkArguments(markers,null,context,null,this.arguments,data);
    this.type=match.getType().getConcreteType(data);
  }
  this.arguments.checkTypes(markers,context);
}
Program: 84864
Project: 84864
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,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++) {
      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);
  }
}
Program: 84865
Project: 84865
Buggy source:
@Override public void checkArguments(MarkerList markers,IArguments arguments){
  if (!this.returnTypeResolved) {
    this.resolveReturnType();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  super.checkArguments(markers,arguments);
}

Fixed version (ground truth):
@Override public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  if (!this.returnTypeResolved) {
    this.resolveReturnType();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  super.checkArguments(markers,position,context,arguments);
}
Program: 84866
Project: 84866
Buggy source:
@Override public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,instance,arguments,typeContext);
}

Fixed version (ground truth):
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,position,context,instance,arguments,typeContext);
}
Program: 84867
Project: 84867
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance == null) {
    markers.add(position,"String_Node_Str",this.name);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance == null) {
    markers.add(position,"String_Node_Str",this.name);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}
Program: 84868
Project: 84868
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  return this.variable.checkAccess(markers,position,instance);
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  return this.variable.checkAccess(markers,position,instance,context);
}
Program: 84869
Project: 84869
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  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);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      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);
      return new ThisValue(position,this.theClass.getType());
    }
  }
  return instance;
}
Program: 84870
Project: 84870
Buggy source:
public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance);

Fixed version (ground truth):
public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context);
Program: 84871
Project: 84871
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  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);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}
Program: 84872
Project: 84872
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  return instance;
}
Program: 84873
Project: 84873
Buggy source:
@Override public void checkArguments(MarkerList markers,IArguments arguments){
  int len=arguments.size();
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    len=this.parameterCount - 1;
    arguments.checkVarargsValue(len,this.parameters[len],markers,this.type);
    for (int i=0; i < len; i++) {
      arguments.checkValue(i,this.parameters[i],markers,this.type);
    }
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    arguments.checkValue(i,this.parameters[i],markers,this.type);
  }
}

Fixed version (ground truth):
@Override public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  int len=arguments.size();
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    len=this.parameterCount - 1;
    arguments.checkVarargsValue(len,this.parameters[len],markers,this.type);
    for (int i=0; i < len; i++) {
      arguments.checkValue(i,this.parameters[i],markers,this.type);
    }
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    arguments.checkValue(i,this.parameters[i],markers,this.type);
  }
}
Program: 84874
Project: 84874
Buggy source:
public void checkArguments(MarkerList markers,IArguments arguments);

Fixed version (ground truth):
public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments);
Program: 84875
Project: 84875
Buggy source:
public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext);

Fixed version (ground truth):
public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext);
Program: 84876
Project: 84876
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.getVisibility(this)) {
case IContext.STATIC:
    markers.add(position,"String_Node_Str",this.name);
  break;
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) {
this.checkMutating(markers,arguments.getFirstValue());
}
 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.getVisibility(this)) {
case IContext.STATIC:
    markers.add(position,"String_Node_Str",this.name);
  break;
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());
}
}
}
Program: 84877
Project: 84877
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    this.value.checkTypes(markers,context);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    this.checkOverride(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    this.checkOverride(markers,context);
  }
}
Program: 84878
Project: 84878
Buggy source:
@Override public int getSignatureMatch(Name name,IValue instance,IArguments arguments){
  if (name != null && name != this.name) {
    return 0;
  }
  if (arguments == null) {
    return 1;
  }
  int parIndex=0;
  int match=1;
  int len=arguments.size();
  int mods=this.modifiers & Modifiers.INFIX;
  if (instance != null && mods == Modifiers.INFIX) {
    IType t2=this.parameters[0].getType();
    int m=instance.getTypeMatch(t2);
    if (m == 0) {
      return 0;
    }
    match+=m;
    parIndex=1;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int parCount=this.parameterCount - 1;
    if (len <= parCount) {
      return 0;
    }
    int m;
    IParameter varParam=this.parameters[parCount];
    for (int i=parIndex; i < parCount; i++) {
      IParameter par=this.parameters[i + parIndex];
      m=arguments.getTypeMatch(i,par);
      if (m == 0) {
        return 0;
      }
      match+=m;
    }
    for (int i=parCount + parIndex; i < len; i++) {
      m=arguments.getVarargsTypeMatch(i,varParam);
      if (m == 0) {
        return 0;
      }
      match+=m;
    }
    return match;
  }
 else   if (len > this.parameterCount) {
    return 0;
  }
  for (int i=0; parIndex < this.parameterCount; parIndex++, i++) {
    IParameter par=this.parameters[parIndex];
    int m=arguments.getTypeMatch(i,par);
    if (m == 0) {
      return 0;
    }
    match+=m;
  }
  return match;
}

Fixed version (ground truth):
@Override public int getSignatureMatch(Name name,IValue instance,IArguments arguments){
  if (name != null && name != this.name) {
    return 0;
  }
  if (arguments == null) {
    return 1;
  }
  if (instance == null && this.modifiers == Modifiers.PREFIX) {
    int m=arguments.getFirstValue().getTypeMatch(this.theClass.getType());
    if (m == 0) {
      return 0;
    }
    return 1 + m;
  }
  int parIndex=0;
  int match=1;
  int len=arguments.size();
  int mods=this.modifiers & Modifiers.INFIX;
  if (instance != null && mods == Modifiers.INFIX) {
    IType t2=this.parameters[0].getType();
    int m=instance.getTypeMatch(t2);
    if (m == 0) {
      return 0;
    }
    match+=m;
    parIndex=1;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int parCount=this.parameterCount - 1;
    if (len <= parCount) {
      return 0;
    }
    int m;
    IParameter varParam=this.parameters[parCount];
    for (int i=parIndex; i < parCount; i++) {
      IParameter par=this.parameters[i + parIndex];
      m=arguments.getTypeMatch(i,par);
      if (m == 0) {
        return 0;
      }
      match+=m;
    }
    for (int i=parCount + parIndex; i < len; i++) {
      m=arguments.getVarargsTypeMatch(i,varParam);
      if (m == 0) {
        return 0;
      }
      match+=m;
    }
    return match;
  }
 else   if (len > this.parameterCount) {
    return 0;
  }
  for (int i=0; parIndex < this.parameterCount; parIndex++, i++) {
    IParameter par=this.parameters[parIndex];
    int m=arguments.getTypeMatch(i,par);
    if (m == 0) {
      return 0;
    }
    match+=m;
  }
  return match;
}
Program: 84880
Project: 84880
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  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);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}
Program: 84881
Project: 84881
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  return instance;
}
Program: 84882
Project: 84882
Buggy source:
@Override public IType getType(){
  if (this.requiredType != null) {
    return this.requiredType;
  }
  return this.requiredType=this.values[this.valueCount - 1].getType();
}

Fixed version (ground truth):
@Override public IType getType(){
  if (this.requiredType != null) {
    return this.requiredType;
  }
  if (this.valueCount == 0) {
    return this.requiredType=Types.VOID;
  }
  return this.requiredType=this.values[this.valueCount - 1].getType();
}
Program: 84884
Project: 84884
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.value != null) {
    this.value.check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.value != null) {
    this.value.check(markers,context);
  }
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
  }
}
Program: 84885
Project: 84885
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.get != null) {
    this.get.check(markers,context);
  }
  if (this.set != null) {
    this.set.check(markers,context);
  }
 else   if (this.get == null) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.get != null) {
    this.get.check(markers,context);
  }
  if (this.set != null) {
    this.set.check(markers,context);
    if (this.type == Types.VOID) {
      markers.add(this.position,"String_Node_Str");
    }
  }
 else   if (this.get == null) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
}
Program: 84886
Project: 84886
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  this.value.check(markers,context);
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  this.value.check(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
  }
}
Program: 84887
Project: 84887
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
  }
}
Program: 84888
Project: 84888
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
  }
}
Program: 84889
Project: 84889
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label conditionLabel=this.conditionLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeTargetLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(conditionLabel);
  this.condition.writeJump(writer,startLabel);
  writer.writeLabel(endLabel);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label conditionLabel=this.conditionLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeTargetLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(conditionLabel);
  if (this.condition != null) {
    this.condition.writeJump(writer,startLabel);
  }
 else {
    writer.writeJumpInsn(Opcodes.GOTO,startLabel);
  }
  writer.writeLabel(endLabel);
}
Program: 84890
Project: 84890
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.check(markers,context);
  }
  if (this.condition != null) {
    this.condition.check(markers,context);
  }
 else {
    markers.add(this.position,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.check(markers,context);
  }
  if (this.condition != null) {
    this.condition.check(markers,context);
  }
}
Program: 84891
Project: 84891
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.check(markers,context);
  }
  if (this.condition != null) {
    IValue condition1=this.condition.withType(Types.BOOLEAN);
    if (condition1 == null) {
      Marker marker=markers.create(this.condition.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.condition.getType());
    }
 else {
      this.condition=condition1;
    }
    this.condition.checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.checkTypes(markers,context);
  }
  if (this.condition != null) {
    IValue condition1=this.condition.withType(Types.BOOLEAN);
    if (condition1 == null) {
      Marker marker=markers.create(this.condition.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.condition.getType());
    }
 else {
      this.condition=condition1;
    }
    this.condition.checkTypes(markers,context);
  }
}
Program: 84892
Project: 84892
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.doStart);
  if (this.action != null) {
    buffer.append(' ');
    this.action.toString(prefix,buffer);
    buffer.append(' ');
  }
  buffer.append(Formatting.Statements.doWhile);
  if (this.condition != null) {
    this.condition.toString(prefix,buffer);
  }
  buffer.append(Formatting.Statements.doEnd);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.doStart);
  if (this.action != null) {
    buffer.append(' ');
    this.action.toString(prefix,buffer);
  }
  if (this.condition != null) {
    buffer.append(' ');
    buffer.append(Formatting.Statements.doWhile);
    this.condition.toString(prefix,buffer);
    buffer.append(Formatting.Statements.doEnd);
  }
}
Program: 84893
Project: 84893
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  org.objectweb.asm.Label elseStart=new org.objectweb.asm.Label();
  if (this.elseThen != null) {
    org.objectweb.asm.Label elseEnd=new org.objectweb.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;
  }
  org.objectweb.asm.Label elseStart=new org.objectweb.asm.Label();
  if (this.elseThen != null) {
    org.objectweb.asm.Label elseEnd=new org.objectweb.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);
  }
}
Program: 84894
Project: 84894
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar){
  return this.type.resolveType(typeVar);
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  return concrete.isArrayType() ? this.type.resolveType(typeVar,concrete.getElementType()) : null;
}
Program: 84895
Project: 84895
Buggy source:
public static IType getPrimitiveType(IType type){
  if (type.isArrayType()) {
    return type;
  }
  IClass iclass=type.getTheClass();
  if (iclass == Types.VOID_CLASS) {
    return Types.VOID;
  }
  if (iclass == Types.BYTE_CLASS) {
    return Types.BYTE;
  }
  if (iclass == Types.SHORT_CLASS) {
    return Types.SHORT;
  }
  if (iclass == Types.CHAR_CLASS) {
    return Types.CHAR;
  }
  if (iclass == Types.INT_CLASS) {
    return Types.INT;
  }
  if (iclass == Types.LONG_CLASS) {
    return Types.LONG;
  }
  if (iclass == Types.FLOAT_CLASS) {
    return Types.FLOAT;
  }
  if (iclass == Types.DOUBLE_CLASS) {
    return Types.DOUBLE;
  }
  return type;
}

Fixed version (ground truth):
public static IType getPrimitiveType(IType type){
  if (type.isArrayType()) {
    return type;
  }
  IClass iclass=type.getTheClass();
  if (iclass == Types.VOID_CLASS) {
    return Types.VOID;
  }
  if (iclass == Types.BOOLEAN_CLASS) {
    return Types.BOOLEAN;
  }
  if (iclass == Types.BYTE_CLASS) {
    return Types.BYTE;
  }
  if (iclass == Types.SHORT_CLASS) {
    return Types.SHORT;
  }
  if (iclass == Types.CHAR_CLASS) {
    return Types.CHAR;
  }
  if (iclass == Types.INT_CLASS) {
    return Types.INT;
  }
  if (iclass == Types.LONG_CLASS) {
    return Types.LONG;
  }
  if (iclass == Types.FLOAT_CLASS) {
    return Types.FLOAT;
  }
  if (iclass == Types.DOUBLE_CLASS) {
    return Types.DOUBLE;
  }
  return type;
}
Program: 84896
Project: 84896
Buggy source:
public static void readMethodType(String desc,IMethodSignature method){
  int i=1;
  if (desc.charAt(0) == '<') {
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,method);
    }
    i+=2;
  }
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,method);
  }
  i++;
  readTyped(desc,i,method);
}

Fixed version (ground truth):
public static void readMethodType(String desc,IMethodSignature method){
  int i=1;
  if (desc.charAt(0) == '<') {
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,method);
    }
    i+=2;
  }
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,method);
  }
  i++;
  i=readTyped(desc,i,method);
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,method);
  }
}
Program: 84897
Project: 84897
Buggy source:
public static void readConstructorType(String desc,IConstructor constructor){
  int i=1;
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,constructor);
  }
}

Fixed version (ground truth):
public static void readConstructorType(String desc,IConstructor constructor){
  int i=1;
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,constructor);
  }
  i+=2;
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,constructor);
  }
}
Program: 84898
Project: 84898
Buggy source:
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.NATIVE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.NATIVE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}
Program: 84901
Project: 84901
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label conditionLabel=this.conditionLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(conditionLabel);
  this.condition.writeJump(writer,startLabel);
  writer.writeLabel(endLabel);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label conditionLabel=this.conditionLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeTargetLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(conditionLabel);
  this.condition.writeJump(writer,startLabel);
  writer.writeLabel(endLabel);
}
Program: 84902
Project: 84902
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.doStart);
  if (this.action != null) {
    if (this.action.isStatement()) {
      buffer.append('\n').append(prefix);
      this.action.toString(prefix,buffer);
      buffer.append('\n').append(prefix);
    }
 else {
      buffer.append(' ');
      this.action.toString(prefix,buffer);
      buffer.append(' ');
    }
  }
  buffer.append(Formatting.Statements.doWhile);
  if (this.condition != null) {
    this.condition.toString(prefix,buffer);
  }
  buffer.append(Formatting.Statements.doEnd);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.doStart);
  if (this.action != null) {
    buffer.append(' ');
    this.action.toString(prefix,buffer);
    buffer.append(' ');
  }
  buffer.append(Formatting.Statements.doWhile);
  if (this.condition != null) {
    this.condition.toString(prefix,buffer);
  }
  buffer.append(Formatting.Statements.doEnd);
}
Program: 84903
Project: 84903
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeLabel(startLabel);
  this.condition.writeInvJump(writer,endLabel);
  this.action.writeStatement(writer);
  writer.writeJumpInsn(Opcodes.GOTO,startLabel);
  writer.writeLabel(endLabel);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeTargetLabel(startLabel);
  this.condition.writeInvJump(writer,endLabel);
  this.action.writeStatement(writer);
  writer.writeJumpInsn(Opcodes.GOTO,startLabel);
  writer.writeLabel(endLabel);
}
Program: 84904
Project: 84904
Buggy source:
public static void compile(File file,IClassCompilable iclass){
  FileUtils.createFile(file);
  try (OutputStream os=new BufferedOutputStream(new FileOutputStream(file))){
    ClassWriter writer=new ClassWriter();
    iclass.write(writer);
    writer.visitEnd();
    byte[] bytes=writer.toByteArray();
    os.write(bytes,0,bytes.length);
  }
 catch (  Throwable ex) {
    DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
  }
}

Fixed version (ground truth):
public static void compile(File file,IClassCompilable iclass){
  FileUtils.createFile(file);
  try (OutputStream os=new BufferedOutputStream(new FileOutputStream(file))){
    ClassWriter writer=new ClassWriter();
    iclass.write(writer);
    writer.visitEnd();
    byte[] bytes=writer.toByteArray();
    os.write(bytes,0,bytes.length);
  }
 catch (  Throwable ex) {
    DyvilCompiler.logger.warning("String_Node_Str" + file + "String_Node_Str"+ ex.getMessage());
    DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
  }
}
Program: 84905
Project: 84905
Buggy source:
public void visitVarInsn(int opcode,int index) throws BytecodeException {
switch (opcode) {
case ILOAD:
    this.push(INT);
  return;
case LLOAD:
this.push(LONG);
return;
case FLOAD:
this.push(FLOAT);
return;
case DLOAD:
this.push(DOUBLE);
return;
case ALOAD:
this.push(this.locals[index]);
return;
case ISTORE:
this.setLocal(index,INT);
this.pop();
return;
case LSTORE:
this.setLocal(index,LONG);
this.pop();
return;
case FSTORE:
this.setLocal(index,FLOAT);
this.pop();
return;
case DSTORE:
this.setLocal(index,DOUBLE);
this.pop();
return;
case ASTORE:
if (index > this.localCount) {
this.setLocal(index,this.stack[this.stackCount - 1]);
}
this.pop();
return;
}
}

Fixed version (ground truth):
public void visitVarInsn(int opcode,int index) throws BytecodeException {
switch (opcode) {
case ILOAD:
    this.push(INT);
  return;
case LLOAD:
this.push(LONG);
return;
case FLOAD:
this.push(FLOAT);
return;
case DLOAD:
this.push(DOUBLE);
return;
case ALOAD:
this.push(this.locals[index]);
return;
case ISTORE:
this.setLocal(index,INT);
this.pop();
return;
case LSTORE:
this.setLocal(index,LONG);
this.pop();
return;
case FSTORE:
this.setLocal(index,FLOAT);
this.pop();
return;
case DSTORE:
this.setLocal(index,DOUBLE);
this.pop();
return;
case ASTORE:
if (index >= this.localCount) {
this.setLocal(index,this.peek());
}
this.pop();
return;
}
}
Program: 84906
Project: 84906
Buggy source:
public static Object fieldType(String desc){
  char c=desc.charAt(0);
switch (c) {
case 'V':
    return null;
case 'B':
  return ClassFormat.BYTE;
case 'S':
return ClassFormat.SHORT;
case 'C':
return ClassFormat.CHAR;
case 'I':
return ClassFormat.INT;
case 'J':
return ClassFormat.LONG;
case 'F':
return ClassFormat.FLOAT;
case 'D':
return ClassFormat.DOUBLE;
case '[':
return desc;
case 'L':
return desc.substring(1,desc.length() - 1);
default :
return null;
}
}

Fixed version (ground truth):
public static Object fieldType(String desc){
  char c=desc.charAt(0);
switch (c) {
case 'V':
    return null;
case 'Z':
  return ClassFormat.BOOLEAN;
case 'B':
return ClassFormat.BYTE;
case 'S':
return ClassFormat.SHORT;
case 'C':
return ClassFormat.CHAR;
case 'I':
return ClassFormat.INT;
case 'J':
return ClassFormat.LONG;
case 'F':
return ClassFormat.FLOAT;
case 'D':
return ClassFormat.DOUBLE;
case '[':
return desc;
case 'L':
return desc.substring(1,desc.length() - 1);
default :
return null;
}
}
Program: 84907
Project: 84907
Buggy source:
public static Object returnType(String desc){
  int index=desc.lastIndexOf(')') + 1;
  char c=desc.charAt(index);
switch (c) {
case 'V':
    return null;
case 'B':
  return ClassFormat.BYTE;
case 'S':
return ClassFormat.SHORT;
case 'C':
return ClassFormat.CHAR;
case 'I':
return ClassFormat.INT;
case 'J':
return ClassFormat.LONG;
case 'F':
return ClassFormat.FLOAT;
case 'D':
return ClassFormat.DOUBLE;
case '[':
return desc.substring(index);
case 'L':
return desc.substring(index + 1,desc.length() - 1);
default :
return null;
}
}

Fixed version (ground truth):
public static Object returnType(String desc){
  int index=desc.lastIndexOf(')') + 1;
  char c=desc.charAt(index);
switch (c) {
case 'V':
    return null;
case 'Z':
  return ClassFormat.BOOLEAN;
case 'B':
return ClassFormat.BYTE;
case 'S':
return ClassFormat.SHORT;
case 'C':
return ClassFormat.CHAR;
case 'I':
return ClassFormat.INT;
case 'J':
return ClassFormat.LONG;
case 'F':
return ClassFormat.FLOAT;
case 'D':
return ClassFormat.DOUBLE;
case '[':
return desc.substring(index);
case 'L':
return desc.substring(index + 1,desc.length() - 1);
default :
return null;
}
}