nus-yam/ex-repair huggingface dataset:
Program: 83189
Project: 83189
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: 83190
Project: 83190
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: 83191
Project: 83191
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: 83192
Project: 83192
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: 83193
Project: 83193
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: 83194
Project: 83194
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: 83195
Project: 83195
Buggy source:
private Dlex(){
}

Fixed version (ground truth):
public Dlex(MarkerList markers){
  this.markers=markers;
}
Program: 83197
Project: 83197
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: 83198
Project: 83198
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: 83199
Project: 83199
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: 83200
Project: 83200
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: 83201
Project: 83201
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: 83202
Project: 83202
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: 83203
Project: 83203
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: 83204
Project: 83204
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: 83205
Project: 83205
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: 83206
Project: 83206
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: 83207
Project: 83207
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: 83208
Project: 83208
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: 83210
Project: 83210
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: 83211
Project: 83211
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: 83212
Project: 83212
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: 83213
Project: 83213
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: 83214
Project: 83214
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);
}
Program: 83216
Project: 83216
Buggy source:
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  super.cleanup(context,compilableList);
  if (this.defaultValue != null) {
    compilableList.addCompilable(this);
    this.defaultValue=this.defaultValue.cleanup(context,compilableList);
  }
}

Fixed version (ground truth):
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  super.cleanup(context,compilableList);
  if (this.defaultValue != null) {
    this.defaultValue=this.defaultValue.cleanup(context,compilableList);
  }
}
Program: 83217
Project: 83217
Buggy source:
@Override public IValue foldConstants(){
  this.value=this.value.foldConstants();
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].foldConstants();
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue foldConstants(){
  if (this.value != null) {
    this.value=this.value.foldConstants();
  }
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].foldConstants();
  }
  return this;
}
Program: 83218
Project: 83218
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  this.value=this.value.withType(type,type,markers,context);
  for (int i=0; i < this.caseCount; i++) {
    MatchCase c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPattern().getPosition(),"String_Node_Str");
    }
    c.resolve(markers,type,context);
    if (c.isExhaustive()) {
      this.exhaustive=true;
    }
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  IType type;
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    type=this.value.getType();
    this.value=this.value.withType(type,type,markers,context);
  }
 else {
    type=Types.ANY;
    markers.add(this.position,"String_Node_Str");
  }
  for (int i=0; i < this.caseCount; i++) {
    MatchCase c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPattern().getPosition(),"String_Node_Str");
    }
    c.resolve(markers,type,context);
    if (c.isExhaustive()) {
      this.exhaustive=true;
    }
  }
  return this;
}
Program: 83219
Project: 83219
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.value.check(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.value != null) {
    this.value.check(markers,context);
  }
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].check(markers,context);
  }
}
Program: 83220
Project: 83220
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.value != null) {
    this.value.checkTypes(markers,context);
  }
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].checkTypes(markers,context);
  }
}
Program: 83221
Project: 83221
Buggy source:
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].cleanup(context,compilableList);
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  if (this.value != null) {
    this.value=this.value.cleanup(context,compilableList);
  }
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].cleanup(context,compilableList);
  }
  return this;
}
Program: 83222
Project: 83222
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.value.resolveTypes(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].resolveTypes(markers,context);
  }
}
Program: 83224
Project: 83224
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.check(markers,new CombiningContext(this,context));
  }
  for (int i=0; i < this.catchBlockCount; i++) {
    CatchBlock block=this.catchBlocks[i];
    if (!Types.THROWABLE.isSuperTypeOf(block.type)) {
      Marker marker=markers.create(block.type.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + block.type);
    }
    block.action.check(markers,context);
  }
  if (this.finallyBlock != null) {
    this.finallyBlock.check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.action != null) {
    this.action.check(markers,new CombiningContext(this,context));
  }
  for (int i=0; i < this.catchBlockCount; i++) {
    CatchBlock block=this.catchBlocks[i];
    if (!Types.THROWABLE.isSuperTypeOf(block.type)) {
      Marker marker=markers.create(block.position,"String_Node_Str");
      marker.addInfo("String_Node_Str" + block.type);
    }
    block.action.check(markers,context);
  }
  if (this.finallyBlock != null) {
    this.finallyBlock.check(markers,context);
  }
}
Program: 83225
Project: 83225
Buggy source:
private static int getMode(char c,String code,int i){
switch (c) {
case '`':
    return SPECIAL_IDENTIFIER;
case '#':
  if (code.charAt(i + 1) == '[') {
    return GENERIC_CALL;
  }
return IDENTIFIER | MOD_SYMBOL;
case '"':
return STRING;
case '\'':
return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_2;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
case '_':
case '$':
return IDENTIFIER | MOD_SYMBOL | MOD_LETTER;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}

Fixed version (ground truth):
private static int getMode(char c,String code,int i){
switch (c) {
case '`':
    return SPECIAL_IDENTIFIER;
case '#':
  if (code.charAt(i + 1) == '[') {
    return GENERIC_CALL;
  }
return IDENTIFIER | MOD_SYMBOL;
case '"':
return STRING;
case '\'':
return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_2;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
case '_':
case '$':
return IDENTIFIER | MOD_SYMBOL | MOD_LETTER;
case '-':
if (isDigit(code.charAt(i + 1))) {
return INT;
}
return IDENTIFIER | MOD_SYMBOL;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}
Program: 83227
Project: 83227
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == ACTION) {
    pm.pushParser(pm.newExpressionParser(this),true);
    this.mode=CATCH;
    return;
  }
  int type=token.type();
  if (this.mode == CATCH) {
    if (type == Keywords.CATCH) {
      this.statement.addCatchBlock(this.catchBlock=new CatchBlock(token.raw()));
      this.mode=CATCH_OPEN;
      return;
    }
    if (type == Keywords.FINALLY) {
      pm.popParser();
      pm.pushParser(pm.newExpressionParser(this));
      this.mode=0;
      return;
    }
    if (ParserUtil.isTerminator(type)) {
      int next=token.next().type();
      if (next != Keywords.CATCH && next != Keywords.FINALLY) {
        pm.popParser(true);
      }
      return;
    }
    pm.popParser(true);
  }
  if (this.mode == CATCH_OPEN) {
    this.mode=CATCH_VAR;
    pm.pushParser(pm.newTypeParser(this.catchBlock));
    if (type == Symbols.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CATCH_VAR) {
    this.mode=CATCH_CLOSE;
    if (ParserUtil.isIdentifier(type)) {
      this.catchBlock.varName=token.nameValue();
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CATCH_CLOSE) {
    this.mode=CATCH;
    pm.pushParser(pm.newExpressionParser(this.catchBlock));
    if (type == Symbols.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == ACTION) {
    pm.pushParser(pm.newExpressionParser(this),true);
    this.mode=CATCH;
    return;
  }
  int type=token.type();
  if (this.mode == CATCH) {
    if (type == Keywords.CATCH) {
      this.statement.addCatchBlock(this.catchBlock=new CatchBlock(token.raw()));
      this.mode=CATCH_OPEN;
      return;
    }
    if (type == Keywords.FINALLY) {
      pm.popParser();
      pm.pushParser(pm.newExpressionParser(this));
      this.mode=0;
      return;
    }
    if (ParserUtil.isTerminator(type)) {
      IToken next=token.getNext();
      if (next == null) {
        pm.popParser(true);
        return;
      }
      int nextType=token.next().type();
      if (nextType != Keywords.CATCH && nextType != Keywords.FINALLY) {
        pm.popParser(true);
      }
      return;
    }
    pm.popParser(true);
  }
  if (this.mode == CATCH_OPEN) {
    this.mode=CATCH_VAR;
    pm.pushParser(pm.newTypeParser(this.catchBlock));
    if (type == Symbols.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CATCH_VAR) {
    this.mode=CATCH_CLOSE;
    if (ParserUtil.isIdentifier(type)) {
      this.catchBlock.varName=token.nameValue();
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CATCH_CLOSE) {
    this.mode=CATCH;
    pm.pushParser(pm.newExpressionParser(this.catchBlock));
    if (type == Symbols.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
}
Program: 83228
Project: 83228
Buggy source:
public static synchronized void loop(){
  System.out.print("String_Node_Str");
  try {
    currentCode=reader.readLine();
    TokenIterator tokens=Dlex.tokenIterator(currentCode + "String_Node_Str");
    REPLContext.newClassName();
    if (parser.parse(tokens,new DyvilUnitParser(context))) {
      return;
    }
    if (parser.parse(tokens,new ClassBodyParser(context))) {
      return;
    }
    if (parser.parse(tokens,new ExpressionParser(context))) {
      return;
    }
  }
 catch (  Throwable t) {
    t.printStackTrace();
  }
}

Fixed version (ground truth):
public static synchronized void loop(){
  System.out.print("String_Node_Str");
  try {
    currentCode=reader.readLine();
    TokenIterator tokens=Dlex.tokenIterator(currentCode + "String_Node_Str");
    REPLContext.newClassName();
    if (parser.parse(null,tokens,new DyvilUnitParser(context))) {
      return;
    }
    if (parser.parse(null,tokens,new ClassBodyParser(context))) {
      return;
    }
    MarkerList markers=new MarkerList();
    parser.parse(markers,tokens,new ExpressionParser(context));
    StringBuilder buf=new StringBuilder();
    for (    Marker m : markers) {
      m.log(currentCode,buf);
    }
    System.out.println(buf.toString());
  }
 catch (  Throwable t) {
    t.printStackTrace();
  }
}
Program: 83229
Project: 83229
Buggy source:
public boolean parse(TokenIterator tokens,Parser parser){
  this.tokens=tokens;
  this.parser=parser;
  this.skip=0;
  this.reparse=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 (    SyntaxError ex) {
      return false;
    }
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 true;
}

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;
  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 (    SyntaxError ex) {
      if (markers == null) {
        return false;
      }
      markers.add(ex);
    }
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 true;
}
Program: 83230
Project: 83230
Buggy source:
private static boolean isAdaptableTo(Class<?> fromType,Class<?> toType,boolean strict){
  if (fromType.equals(toType)) {
    return true;
  }
  if (fromType.isPrimitive()) {
    Wrapper wfrom=forPrimitiveType(fromType);
    if (toType.isPrimitive()) {
      Wrapper wto=forPrimitiveType(toType);
      return wto.isConvertibleFrom(wfrom);
    }
    return toType.isAssignableFrom(wfrom.wrapperType());
  }
  if (toType.isPrimitive()) {
    Wrapper wfrom;
    if (isWrapperType(fromType) && (wfrom=forWrapperType(fromType)).primitiveType().isPrimitive()) {
      Wrapper wto=forPrimitiveType(toType);
      return wto.isConvertibleFrom(wfrom);
    }
    return !strict;
  }
  return !strict || toType.isAssignableFrom(fromType);
}

Fixed version (ground truth):
private static boolean isAdaptableTo(Class<?> fromType,Class<?> toType,boolean strict){
  if (fromType.equals(toType)) {
    return true;
  }
  if (fromType.isPrimitive()) {
    Wrapper wfrom=Wrapper.forPrimitiveType(fromType);
    if (toType.isPrimitive()) {
      Wrapper wto=Wrapper.forPrimitiveType(toType);
      return wto.isConvertibleFrom(wfrom);
    }
    return toType.isAssignableFrom(wfrom.wrapperType());
  }
  if (toType.isPrimitive()) {
    Wrapper wfrom;
    if (Wrapper.isWrapperType(fromType) && (wfrom=Wrapper.forWrapperType(fromType)).primitiveType().isPrimitive()) {
      Wrapper wto=Wrapper.forPrimitiveType(toType);
      return wto.isConvertibleFrom(wfrom);
    }
    return !strict;
  }
  return !strict || toType.isAssignableFrom(fromType);
}
Program: 83231
Project: 83231
Buggy source:
private void convertArgumentTypes(MethodType samType){
  int lvIndex=0;
  boolean samIncludesReceiver=AnonymousClassLMF.this.implIsInstanceMethod && AnonymousClassLMF.this.invokedType.parameterCount() == 0;
  int samReceiverLength=samIncludesReceiver ? 1 : 0;
  if (samIncludesReceiver) {
    Class<?> rcvrType=samType.parameterType(0);
    this.visitVarInsn(getLoadOpcode(rcvrType),lvIndex + 1);
    lvIndex+=getParameterSize(rcvrType);
    TypeConverter.convertType(this,rcvrType,AnonymousClassLMF.this.implDefiningClass,AnonymousClassLMF.this.instantiatedMethodType.parameterType(0));
  }
  int samParametersLength=samType.parameterCount();
  int argOffset=AnonymousClassLMF.this.implMethodType.parameterCount() - samParametersLength;
  for (int i=samReceiverLength; i < samParametersLength; i++) {
    Class<?> argType=samType.parameterType(i);
    this.visitVarInsn(getLoadOpcode(argType),lvIndex + 1);
    lvIndex+=getParameterSize(argType);
    TypeConverter.convertType(this,argType,AnonymousClassLMF.this.implMethodType.parameterType(argOffset + i),AnonymousClassLMF.this.instantiatedMethodType.parameterType(i));
  }
}

Fixed version (ground truth):
private void convertArgumentTypes(MethodType samType){
  int lvIndex=0;
  boolean samIncludesReceiver=AnonymousClassLMF.this.implIsInstanceMethod && AnonymousClassLMF.this.invokedType.parameterCount() == 0;
  int samReceiverLength=samIncludesReceiver ? 1 : 0;
  if (samIncludesReceiver) {
    Class<?> rcvrType=samType.parameterType(0);
    this.mv.visitVarInsn(getLoadOpcode(rcvrType),lvIndex + 1);
    lvIndex+=getParameterSize(rcvrType);
    TypeConverter.convertType(this.mv,rcvrType,AnonymousClassLMF.this.implDefiningClass,AnonymousClassLMF.this.instantiatedMethodType.parameterType(0));
  }
  int samParametersLength=samType.parameterCount();
  int argOffset=AnonymousClassLMF.this.implMethodType.parameterCount() - samParametersLength;
  for (int i=samReceiverLength; i < samParametersLength; i++) {
    Class<?> argType=samType.parameterType(i);
    this.mv.visitVarInsn(getLoadOpcode(argType),lvIndex + 1);
    lvIndex+=getParameterSize(argType);
    TypeConverter.convertType(this.mv,argType,AnonymousClassLMF.this.implMethodType.parameterType(argOffset + i),AnonymousClassLMF.this.instantiatedMethodType.parameterType(i));
  }
}
Program: 83232
Project: 83232
Buggy source:
public AnonymousClassLMF(MethodHandles.Lookup caller,MethodType invokedType,String samMethodName,MethodType samMethodType,MethodHandle implMethod,MethodType instantiatedMethodType,String toString) throws LambdaConversionException {
  super(caller,invokedType,samMethodName,samMethodType,implMethod,instantiatedMethodType);
  this.implMethodClassName=this.implDefiningClass.getName().replace('.','/');
  this.implMethodName=this.implInfo.getName();
  this.implMethodDesc=this.implMethodType.toMethodDescriptorString();
  this.implMethodReturnClass=this.implKind == MethodHandleInfo.REF_newInvokeSpecial ? this.implDefiningClass : this.implMethodType.returnType();
  this.constructorType=invokedType.changeReturnType(Void.TYPE);
  this.lambdaClassName=this.targetClass.getName().replace('.','/') + "String_Node_Str" + counter.incrementAndGet();
  this.cw=new ClassWriter(ClassWriter.COMPUTE_MAXS);
  int parameterCount=invokedType.parameterCount();
  if (parameterCount > 0) {
    this.argNames=new String[parameterCount];
    this.argDescs=new String[parameterCount];
    for (int i=0; i < parameterCount; i++) {
      this.argNames[i]="String_Node_Str" + (i + 1);
      this.argDescs[i]=BytecodeDescriptor.unparse(invokedType.parameterType(i));
    }
  }
 else {
    this.argNames=this.argDescs=EMPTY_STRING_ARRAY;
  }
  this.toString=toString;
}

Fixed version (ground truth):
public AnonymousClassLMF(MethodHandles.Lookup caller,MethodType invokedType,String samMethodName,MethodType samMethodType,MethodHandle implMethod,MethodType instantiatedMethodType,String toString) throws LambdaConversionException {
  super(caller,invokedType,samMethodName,samMethodType,implMethod,instantiatedMethodType);
  this.implMethodClassName=this.implDefiningClass.getName().replace('.','/');
  this.implMethodName=this.implInfo.getName();
  this.implMethodDesc=this.implMethodType.toMethodDescriptorString();
  this.implMethodReturnClass=this.implKind == MethodHandleInfo.REF_newInvokeSpecial ? this.implDefiningClass : this.implMethodType.returnType();
  this.constructorType=invokedType.changeReturnType(Void.TYPE);
  this.lambdaClassName=this.targetClass.getName().replace('.','/') + "String_Node_Str" + counter.incrementAndGet();
  this.cw=new ClassWriter(ClassWriter.COMPUTE_MAXS);
  int parameterCount=invokedType.parameterCount();
  if (parameterCount > 0) {
    this.argNames=new String[parameterCount];
    this.argDescs=new String[parameterCount];
    for (int i=0; i < parameterCount; i++) {
      this.argNames[i]="String_Node_Str" + (i + 1);
      this.argDescs[i]=Type.getDescriptor(invokedType.parameterType(i));
    }
  }
 else {
    this.argNames=this.argDescs=EMPTY_STRING_ARRAY;
  }
  this.toString=toString;
}