nus-yam/ex-repair huggingface dataset:
Program: 84465
Project: 84465
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: 84466
Project: 84466
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: 84467
Project: 84467
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: 84468
Project: 84468
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: 84469
Project: 84469
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: 84470
Project: 84470
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: 84471
Project: 84471
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: 84472
Project: 84472
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: 84473
Project: 84473
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: 84475
Project: 84475
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: 84476
Project: 84476
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: 84477
Project: 84477
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: 84478
Project: 84478
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: 84480
Project: 84480
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: 84482
Project: 84482
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: 84483
Project: 84483
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: 84484
Project: 84484
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: 84485
Project: 84485
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: 84486
Project: 84486
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: 84487
Project: 84487
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;
  }
}
Program: 84488
Project: 84488
Buggy source:
public boolean parse(MarkerList markers,TokenIterator tokens,Parser parser){
  this.tokens=tokens;
  this.parser=parser;
  this.skip=0;
  this.reparse=false;
  this.markers=markers;
  this.syntaxErrors=false;
  IToken token=null, prev=null;
  tokens.reset();
  while (tokens.hasNext()) {
    token=tokens.next();
    token.setPrev(prev);
    prev=token;
  }
  if (prev == null) {
    return false;
  }
  int type=prev.type();
  if (!ParserUtil.isSeperator(type) && type != (Tokens.IDENTIFIER | Tokens.MOD_SYMBOL)) {
    IToken semicolon=new InferredSemicolon(prev.endLine(),prev.endIndex());
    semicolon.setPrev(prev);
    prev.setNext(semicolon);
  }
  tokens.reset();
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      return false;
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.getName()+ "String_Node_Str"+ this.parser.getMode());
    }
  }
  return !this.syntaxErrors;
}

Fixed version (ground truth):
public boolean parse(MarkerList markers,TokenIterator tokens,Parser parser){
  this.tokens=tokens;
  this.parser=parser;
  this.skip=0;
  this.reparse=false;
  this.markers=markers;
  this.syntaxErrors=false;
  IToken token=null, prev=null;
  tokens.reset();
  while (tokens.hasNext()) {
    token=tokens.next();
    token.setPrev(prev);
    prev=token;
  }
  if (prev == null) {
    return false;
  }
  int type=prev.type();
  if (!ParserUtil.isSeperator(type) && type != (Tokens.IDENTIFIER | Tokens.MOD_SYMBOL)) {
    IToken semicolon=new InferredSemicolon(prev.endLine(),prev.endIndex());
    semicolon.setPrev(prev);
    prev.setNext(semicolon);
  }
  tokens.reset();
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      return false;
    }
    if (this.parser == null || (this.syntaxErrors && this.markers == null)) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.getName()+ "String_Node_Str"+ this.parser.getMode());
    }
  }
  return !this.syntaxErrors;
}
Program: 84489
Project: 84489
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType prevType=this.value.getType();
  IValue value1=this.value.withType(this.type,this.type,markers,context);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.type=value1.getType();
    return this;
  }
  if (value1 == null && !prevType.isSuperClassOf(this.type)) {
    markers.add(this.position,"String_Node_Str",prevType,this.type);
    return this;
  }
  if (!this.typeHint && this.type.equals(prevType)) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType prevType=this.value.getType();
  IValue value1=this.value.withType(this.type,this.type,markers,context);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.type=value1.getType();
    return this;
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (primitiveType) {
    if (!primitiveValue) {
      markers.add(this.position,"String_Node_Str");
    }
  }
 else   if (primitiveValue) {
    markers.add(this.position,"String_Node_Str");
  }
  if (value1 == null && !(primitiveType && primitiveValue) && !prevType.isSuperClassOf(this.type)) {
    markers.add(this.position,"String_Node_Str",prevType,this.type);
    return this;
  }
  if (!this.typeHint && this.type.equals(prevType)) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  return this;
}
Program: 84490
Project: 84490
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,context);
  if (this.typeHint) {
    return;
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (primitiveType) {
    if (!primitiveValue) {
      markers.add(this.position,"String_Node_Str");
    }
  }
 else   if (primitiveValue) {
    markers.add(this.position,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,context);
}
Program: 84491
Project: 84491
Buggy source:
protected IValue resolveFieldAccess(MarkerList markers,IContext context){
  if (!ICall.privateAccess(context,this.instance)) {
    IMethod method=ICall.resolveMethod(context,this.instance,this.name,EmptyArguments.INSTANCE);
    if (method != null) {
      AbstractCall mc=this.toMethodCall(method);
      mc.checkArguments(markers,context);
      return mc;
    }
  }
  IDataMember field=ICall.resolveField(context,this.instance,this.name);
  if (field != null) {
    if (field.isEnumConstant()) {
      EnumValue enumValue=new EnumValue(field.getType(),this.name);
      return enumValue;
    }
    this.field=field;
    return this;
  }
  if (this.instance == null) {
    IClass iclass=IContext.resolveClass(context,this.name);
    if (iclass != null) {
      return new ClassAccess(this.position,iclass.getType());
    }
  }
  return null;
}

Fixed version (ground truth):
protected IValue resolveFieldAccess(MarkerList markers,IContext context){
  if (ICall.privateAccess(context,this.instance)) {
    IValue value=this.resolveField(markers,context);
    if (value != null) {
      return value;
    }
    value=this.resolveMethod(markers,context);
    if (value != null) {
      return value;
    }
  }
 else {
    IValue value=this.resolveMethod(markers,context);
    if (value != null) {
      return value;
    }
    value=this.resolveField(markers,context);
    if (value != null) {
      return value;
    }
  }
  if (this.instance == null) {
    IClass iclass=IContext.resolveClass(context,this.name);
    if (iclass != null) {
      return new ClassAccess(this.position,iclass.getType());
    }
  }
  return null;
}
Program: 84492
Project: 84492
Buggy source:
@Override public void tokenize(){
  this.tokens=Dlex.tokenIterator(this.inputFile.getCode());
  this.tokens.inferSemicolons();
}

Fixed version (ground truth):
@Override public void tokenize(){
  this.tokens=new Dlex(this.markers).tokenize(this.inputFile.getCode());
  this.tokens.inferSemicolons();
}
Program: 84493
Project: 84493
Buggy source:
private static IToken addToken(IToken prev,StringBuilder buf,int type,int line,int start){
  String s=buf.toString();
  int len=buf.length();
  buf.delete(0,len);
  return addToken(prev,s,type,line,start,len);
}

Fixed version (ground truth):
private IToken addToken(IToken prev,StringBuilder buf,int type,int line,int start){
  String s=buf.toString();
  int len=buf.length();
  buf.delete(0,len);
  return addToken(prev,s,type,line,start,len);
}
Program: 84494
Project: 84494
Buggy source:
private Dlex(){
}

Fixed version (ground truth):
public Dlex(MarkerList markers){
  this.markers=markers;
}
Program: 84496
Project: 84496
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (!this.isType(type)) {
    return null;
  }
  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;
}

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=this.getType();
  }
 else {
    this.type=type.getConcreteType(typeContext);
  }
  return this;
}
Program: 84497
Project: 84497
Buggy source:
@Override public boolean isType(IType type){
  if (this.type != null && type.isSuperTypeOf(this.type)) {
    return true;
  }
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType lambdaParamType=lambdaParam.getType();
    if (lambdaParamType == null) {
      continue;
    }
    if (!param.getType().equals(lambdaParamType)) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (this.type != null && type.isSuperTypeOf(this.type)) {
    return true;
  }
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  if (iclass == Types.OBJECT_CLASS) {
    return true;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType lambdaParamType=lambdaParam.getType();
    if (lambdaParamType == null) {
      continue;
    }
    if (!param.getType().equals(lambdaParamType)) {
      return false;
    }
  }
  return true;
}
Program: 84498
Project: 84498
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.value.withType(this.type,this.type,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      if (inferType) {
        this.type=value1.getType();
      }
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
    this.type=Types.ANY;
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.type.convertValue(this.value,this.type,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      if (inferType) {
        this.type=value1.getType();
      }
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
    this.type=Types.ANY;
  }
}
Program: 84499
Project: 84499
Buggy source:
public boolean parse(MarkerList markers,TokenIterator tokens,Parser parser){
  this.tokens=tokens;
  this.parser=parser;
  this.skip=0;
  this.reparse=false;
  this.markers=markers;
  IToken token=null, prev=null;
  tokens.reset();
  while (tokens.hasNext()) {
    token=tokens.next();
    token.setPrev(prev);
    prev=token;
  }
  if (prev == null) {
    return false;
  }
  int type=prev.type();
  if (!ParserUtil.isSeperator(type) && type != (Tokens.IDENTIFIER | Tokens.MOD_SYMBOL)) {
    IToken semicolon=new InferredSemicolon(prev.endLine(),prev.endIndex());
    semicolon.setPrev(prev);
    prev.setNext(semicolon);
  }
  tokens.reset();
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      return false;
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.getName()+ "String_Node_Str"+ this.parser.getMode());
    }
  }
  return !this.syntaxErrors;
}

Fixed version (ground truth):
public boolean parse(MarkerList markers,TokenIterator tokens,Parser parser){
  this.tokens=tokens;
  this.parser=parser;
  this.skip=0;
  this.reparse=false;
  this.markers=markers;
  this.syntaxErrors=false;
  IToken token=null, prev=null;
  tokens.reset();
  while (tokens.hasNext()) {
    token=tokens.next();
    token.setPrev(prev);
    prev=token;
  }
  if (prev == null) {
    return false;
  }
  int type=prev.type();
  if (!ParserUtil.isSeperator(type) && type != (Tokens.IDENTIFIER | Tokens.MOD_SYMBOL)) {
    IToken semicolon=new InferredSemicolon(prev.endLine(),prev.endIndex());
    semicolon.setPrev(prev);
    prev.setNext(semicolon);
  }
  tokens.reset();
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      return false;
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.getName()+ "String_Node_Str"+ this.parser.getMode());
    }
  }
  return !this.syntaxErrors;
}
Program: 84500
Project: 84500
Buggy source:
@Override public IValue foldConstants(){
  if (this.field != null && this.field.hasModifier(Modifiers.CONST)) {
    IValue v=this.field.getValue();
    return v != null && v.isConstant() ? v : this;
  }
  if (this.instance != null) {
    this.instance=this.instance.foldConstants();
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue foldConstants(){
  if (this.field != null && this.field.hasModifier(Modifiers.CONST)) {
    IValue v=this.field.getValue();
    return v != null && v.isConstantOrField() ? v : this;
  }
  if (this.instance != null) {
    this.instance=this.instance.foldConstants();
  }
  return this;
}
Program: 84501
Project: 84501
Buggy source:
private static void visitValue(AnnotationVisitor visitor,String key,IValue value){
  int valueType=value.valueTag();
  if (valueType == IValue.ARRAY) {
    AnnotationVisitor arrayVisitor=visitor.visitArray(key);
    for (    IValue v : (IValueList)value) {
      visitValue(arrayVisitor,null,v);
    }
  }
 else   if (valueType == IValue.ENUM) {
    EnumValue enumValue=(EnumValue)value;
    visitor.visitEnum(key,enumValue.type.getExtendedName(),enumValue.name.qualified);
  }
 else   if (value.isConstant()) {
    visitor.visit(key,value.toObject());
  }
}

Fixed version (ground truth):
private static void visitValue(AnnotationVisitor visitor,String key,IValue value){
  int valueType=value.valueTag();
  if (valueType == IValue.ARRAY) {
    AnnotationVisitor arrayVisitor=visitor.visitArray(key);
    Array array=(Array)value;
    int count=array.valueCount();
    for (int i=0; i < count; i++) {
      visitValue(arrayVisitor,null,array.getValue(i));
    }
    arrayVisitor.visitEnd();
  }
 else   if (valueType == IValue.ENUM) {
    EnumValue enumValue=(EnumValue)value;
    visitor.visitEnum(key,enumValue.type.getExtendedName(),enumValue.name.qualified);
  }
 else   if (value.isConstant()) {
    visitor.visit(key,value.toObject());
  }
}
Program: 84502
Project: 84502
Buggy source:
private void write(AnnotationVisitor visitor){
  IClass iclass=this.type.getTheClass();
  int count=iclass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=iclass.getParameter(i);
    visitValue(visitor,param.getName().qualified,this.arguments.getValue(i,param));
  }
}

Fixed version (ground truth):
private void write(AnnotationVisitor visitor){
  IClass iclass=this.type.getTheClass();
  int count=iclass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=iclass.getParameter(i);
    visitValue(visitor,param.getName().qualified,this.arguments.getValue(i,param));
  }
  visitor.visitEnd();
}
Program: 84503
Project: 84503
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.value == null) {
    return type == Types.UNKNOWN || type == Types.VOID ? this : null;
  }
  IValue value1=this.value.withType(type,typeContext,markers,context);
  if (value1 == null) {
    return null;
  }
  this.value=value1;
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.VOID) {
    return this;
  }
  if (this.value == null) {
    return null;
  }
  IValue value1=this.value.withType(type,typeContext,markers,context);
  if (value1 == null) {
    return null;
  }
  this.value=value1;
  return this;
}
Program: 84504
Project: 84504
Buggy source:
@Override public boolean isType(IType type){
  return this.value == null ? type == Types.UNKNOWN || type == Types.VOID : this.value.isType(type);
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (type == Types.VOID) {
    return true;
  }
  return this.value != null && this.value.isType(type);
}
Program: 84505
Project: 84505
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.value.writeExpression(writer);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.writeStatement(writer);
}
Program: 84506
Project: 84506
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type != Types.VOID) {
    return null;
  }
  IValue action1=this.action.withType(Types.VOID,typeContext,markers,context);
  if (action1 == null) {
  }
 else {
    this.action=action1;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type != Types.VOID) {
    return null;
  }
  if (this.action != null) {
    IValue action1=this.action.withType(Types.VOID,typeContext,markers,context);
    if (action1 == null) {
    }
 else {
      this.action=action1;
    }
  }
  return this;
}
Program: 84507
Project: 84507
Buggy source:
/** 
 * Creates a new   {@link ParserManager} with the given {@link Parser}{@code parser} as the current parser, and calls the parser's{@link Parser#begin(ParserManager) begin} method.
 * @see Parser#begin(ParserManager)
 * @param parser the parser
 */
public ParserManager(Parser parser,MarkerList markers){
  this.parser=parser;
  this.markers=markers;
}

Fixed version (ground truth):
public ParserManager(Parser parser,MarkerList markers){
  this.parser=parser;
  this.markers=markers;
}
Program: 84509
Project: 84509
Buggy source:
@Override public void report(SyntaxError error){
  this.pm.jump(this.firstToken);
  this.reset();
  this.pm.pushParser(this.pm.newExpressionParser(this));
  this.mode=SEPARATOR;
}

Fixed version (ground truth):
@Override public void report(SyntaxError error){
  this.pm.jump(this.firstToken);
  this.pm.pushParser(this.pm.newExpressionParser(this));
  this.reset();
  this.mode=SEPARATOR;
}
Program: 84510
Project: 84510
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.parameterCount == 1) {
    IParameter param=this.parameters[0];
    if (param.getType() == Types.UNKNOWN) {
      buffer.append('(');
      param.toString(prefix,buffer);
      buffer.append(')');
    }
 else {
      buffer.append(param.getName());
    }
    buffer.append(' ');
  }
 else   if (this.parameterCount > 1) {
    buffer.append('(');
    IParameter first=this.parameters[0];
    if (first.getType() == Types.UNKNOWN) {
      buffer.append(first.getName());
      for (int i=1; i < this.parameterCount; i++) {
        buffer.append("String_Node_Str").append(this.parameters[i].getName());
      }
    }
 else {
      Util.astToString(prefix,this.parameters,this.parameterCount,"String_Node_Str",buffer);
    }
    buffer.append("String_Node_Str");
  }
  buffer.append(Formatting.Expression.lambdaSeperator);
  this.value.toString(prefix,buffer);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.parameterCount == 1) {
    IParameter param=this.parameters[0];
    if (param.getType() != Types.UNKNOWN) {
      buffer.append('(');
      param.toString(prefix,buffer);
      buffer.append(')');
    }
 else {
      buffer.append(param.getName());
    }
    buffer.append(' ');
  }
 else   if (this.parameterCount > 1) {
    buffer.append('(');
    IParameter first=this.parameters[0];
    if (first.getType() == Types.UNKNOWN) {
      buffer.append(first.getName());
      for (int i=1; i < this.parameterCount; i++) {
        buffer.append("String_Node_Str").append(this.parameters[i].getName());
      }
    }
 else {
      Util.astToString(prefix,this.parameters,this.parameterCount,"String_Node_Str",buffer);
    }
    buffer.append("String_Node_Str");
  }
  buffer.append(Formatting.Expression.lambdaSeperator);
  this.value.toString(prefix,buffer);
}
Program: 84511
Project: 84511
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
  buffer.append(']');
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
  buffer.append(')');
}
Program: 84512
Project: 84512
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
  buffer.append(']');
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
  buffer.append(')');
}
Program: 84513
Project: 84513
Buggy source:
@Override public GenericData getGenericData(GenericData genericData,IValue instance,IArguments arguments){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  return super.getGenericData(genericData,instance,arguments);
}

Fixed version (ground truth):
@Override public GenericData getGenericData(GenericData genericData,IValue instance,IArguments arguments){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.getGenericData(genericData,instance,arguments);
}