nus-yam/ex-repair huggingface dataset:
Program: 83049
Project: 83049
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  this.value.check(markers,context);
  if (this.type.isPrimitive()) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return;
  }
  if (this.value.isPrimitive()) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return;
  }
  IType valueType=this.value.getType();
  if (valueType.classEquals(this.type)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",valueType));
    return;
  }
  if (this.type.isSuperClassOf(valueType)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",valueType,this.type));
    return;
  }
  if (!valueType.isSuperClassOf(this.type)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",valueType,this.type));
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  this.value.check(markers,context);
  if (this.type.isPrimitive()) {
    markers.add(I18n.createError(this.position,"String_Node_Str"));
    return;
  }
  if (this.value.isPrimitive()) {
    markers.add(I18n.createError(this.position,"String_Node_Str"));
    return;
  }
  IType valueType=this.value.getType();
  if (valueType.classEquals(this.type)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",valueType));
    return;
  }
  if (this.type.isSuperClassOf(valueType)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",valueType,this.type));
    return;
  }
  if (!valueType.isSuperClassOf(this.type)) {
    markers.add(I18n.createError(this.position,"String_Node_Str",valueType,this.type));
  }
}
Program: 83050
Project: 83050
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
  Object commonFrameType=this.commonType.getFrameType();
  this.condition.writeInvJump(writer,elseStart);
  this.then.writeExpression(writer,this.commonType);
  writer.getFrame().set(commonFrameType);
  writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
  writer.writeTargetLabel(elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer,this.commonType);
  }
  writer.getFrame().set(commonFrameType);
  writer.writeTargetLabel(elseEnd);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label elseStart=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label elseEnd=new dyvil.tools.asm.Label();
  Object commonFrameType=this.commonType.getFrameType();
  this.condition.writeInvJump(writer,elseStart);
  this.then.writeExpression(writer,this.commonType);
  if (!writer.hasReturn()) {
    writer.getFrame().set(commonFrameType);
    writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
  }
  writer.writeTargetLabel(elseStart);
  if (this.elseThen == null) {
    this.commonType.writeDefaultValue(writer);
  }
 else {
    this.elseThen.writeExpression(writer,this.commonType);
  }
  if (!writer.hasReturn()) {
    writer.getFrame().set(commonFrameType);
  }
  writer.writeTargetLabel(elseEnd);
}
Program: 83052
Project: 83052
Buggy source:
@Override public void end(IType type){
  IClass iclass=type.getTheClass();
  if (iclass != null) {
    iclass.writeInnerClassInfo(this.cw);
  }
  if (!this.hasReturn) {
    this.insnCallback();
    this.mv.visitInsn(type.getReturnOpcode());
  }
  this.mv.visitMaxs(this.frame.maxStack,this.frame.maxLocals);
  this.mv.visitEnd();
}

Fixed version (ground truth):
@Override public void end(IType type){
  IClass iclass=type.getTheClass();
  if (iclass != null) {
    iclass.writeInnerClassInfo(this.cw);
  }
  if (!this.hasReturn) {
    int opcode=type.getReturnOpcode();
    if (opcode == RETURN || this.frame.actualStackCount > 0) {
      this.insnCallback();
      this.mv.visitInsn(opcode);
    }
  }
  this.mv.visitMaxs(this.frame.maxStack,this.frame.maxLocals);
  this.mv.visitEnd();
}
Program: 83054
Project: 83054
Buggy source:
@Override public IMethod getFunctionalMethod(){
  if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    return null;
  }
  IMethod m;
  if (this.body != null) {
    m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  if (this.superType != null) {
    m=this.superType.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    m=this.interfaces[i].getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IMethod getFunctionalMethod(){
  if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    return null;
  }
  if (this.body != null) {
    IMethod m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  return null;
}
Program: 83055
Project: 83055
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.method == null) {
    IType type=this.getType();
    this.withType(type,type,markers,context);
  }
  this.value.checkTypes(markers,new CombiningContext(this,context));
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,new CombiningContext(this,context));
}
Program: 83056
Project: 83056
Buggy source:
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  if (this.capturedFieldCount == 0) {
    if (this.value instanceof AbstractCall && this.value.valueTag() != COMPOUND_CALL) {
      AbstractCall c=(AbstractCall)this.value;
      IMethod method=c.getMethod();
      if (this.checkCall(c.getValue(),c.getArguments(),method)) {
switch (method.getInvokeOpcode()) {
case Opcodes.INVOKEVIRTUAL:
          this.directInvokeOpcode=ClassFormat.H_INVOKEVIRTUAL;
        break;
case Opcodes.INVOKESTATIC:
      this.directInvokeOpcode=ClassFormat.H_INVOKESTATIC;
    break;
case Opcodes.INVOKEINTERFACE:
  this.directInvokeOpcode=ClassFormat.H_INVOKEINTERFACE;
break;
case Opcodes.INVOKESPECIAL:
this.directInvokeOpcode=ClassFormat.H_INVOKESPECIAL;
break;
}
this.name=method.getName().qualified;
this.owner=method.getTheClass().getInternalName();
this.lambdaDesc=method.getDescriptor();
return this;
}
}
 else if (this.value.getClass() == ConstructorCall.class) {
ConstructorCall c=(ConstructorCall)this.value;
IConstructor ctor=c.getConstructor();
if (this.checkCall(null,c.getArguments(),ctor)) {
this.directInvokeOpcode=ClassFormat.H_NEWINVOKESPECIAL;
this.name="String_Node_Str";
this.owner=ctor.getTheClass().getInternalName();
this.lambdaDesc=ctor.getDescriptor();
return this;
}
}
}
compilableList.addCompilable(this);
return this;
}

Fixed version (ground truth):
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  if (this.capturedFieldCount == 0) {
    if (this.value instanceof AbstractCall && this.value.valueTag() != COMPOUND_CALL) {
      AbstractCall c=(AbstractCall)this.value;
      IMethod method=c.getMethod();
      if (method != null && this.checkCall(c.getValue(),c.getArguments(),method)) {
switch (method.getInvokeOpcode()) {
case Opcodes.INVOKEVIRTUAL:
          this.directInvokeOpcode=ClassFormat.H_INVOKEVIRTUAL;
        break;
case Opcodes.INVOKESTATIC:
      this.directInvokeOpcode=ClassFormat.H_INVOKESTATIC;
    break;
case Opcodes.INVOKEINTERFACE:
  this.directInvokeOpcode=ClassFormat.H_INVOKEINTERFACE;
break;
case Opcodes.INVOKESPECIAL:
this.directInvokeOpcode=ClassFormat.H_INVOKESPECIAL;
break;
}
this.name=method.getName().qualified;
this.owner=method.getTheClass().getInternalName();
this.lambdaDesc=method.getDescriptor();
return this;
}
}
 else if (this.value.getClass() == ConstructorCall.class) {
ConstructorCall c=(ConstructorCall)this.value;
IConstructor ctor=c.getConstructor();
if (this.checkCall(null,c.getArguments(),ctor)) {
this.directInvokeOpcode=ClassFormat.H_NEWINVOKESPECIAL;
this.name="String_Node_Str";
this.owner=ctor.getTheClass().getInternalName();
this.lambdaDesc=ctor.getDescriptor();
return this;
}
}
}
compilableList.addCompilable(this);
return this;
}
Program: 83057
Project: 83057
Buggy source:
@Override public IMethod getFunctionalMethod(){
  if ((this.modifiers & Modifiers.ABSTRACT | Modifiers.INTERFACE_CLASS) == 0) {
    return null;
  }
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  IMethod m;
  if (this.body != null) {
    m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    m=this.superType.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    m=this.interfaces[i].getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IMethod getFunctionalMethod(){
  if ((this.modifiers & Modifiers.ABSTRACT | Modifiers.INTERFACE_CLASS) == 0) {
    return null;
  }
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  if (this.body != null) {
    IMethod m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  return null;
}
Program: 83058
Project: 83058
Buggy source:
@Override public void visitParameter(String name,int index){
  this.method.getParameter_(index).setName(Name.getQualified(name));
}

Fixed version (ground truth):
@Override public void visitParameter(String name,int modifiers){
  this.method.getParameter_(this.parameterIndex++).setName(Name.getQualified(name));
}
Program: 83060
Project: 83060
Buggy source:
private IValue makeForStatement(){
  if (this.forEach) {
    return new ForEachStatement(this.position,this.variable,this.action);
  }
  return new ForStatement(this.position,this.variable,this.condition,this.update,this.action);
}

Fixed version (ground truth):
private IValue makeForStatement(){
  if (this.variable != null && this.variable.getType() == null) {
    this.variable=null;
  }
  if (this.forEach) {
    return new ForEachStatement(this.position,this.variable,this.action);
  }
  return new ForStatement(this.position,this.variable,this.condition,this.update,this.action);
}
Program: 83061
Project: 83061
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeInsn(Opcodes.ARETURN);
}
Program: 83062
Project: 83062
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  return type == Types.VOID ? this : null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.isType(type)) {
    return this;
  }
  return null;
}
Program: 83063
Project: 83063
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  writer.writeInsn(Opcodes.ACONST_NULL);
}
Program: 83064
Project: 83064
Buggy source:
@Override public IType getType(){
  return Types.VOID;
}

Fixed version (ground truth):
@Override public IType getType(){
  return this.annotation.getType();
}
Program: 83065
Project: 83065
Buggy source:
@Override public void parse(IParserManager pm,IToken token){
  int type=token.type();
switch (this.mode) {
case NAME:
    if (ParserUtil.isIdentifier(type)) {
      Name name=token.nameValue();
      this.annotation.setType(new NamedType(token.raw(),name));
      this.mode=PARAMETERS_START;
      return;
    }
  pm.report(token,"String_Node_Str");
return;
case PARAMETERS_START:
if (type == Symbols.OPEN_PARENTHESIS) {
IToken next=token.next();
if (ParserUtil.isIdentifier(next.type()) && next.next().type() == Symbols.COLON) {
  ArgumentMap map=new ArgumentMap();
  this.annotation.setArguments(map);
  pm.pushParser(new ExpressionMapParser(map));
}
 else {
  ArgumentList list=new ArgumentList();
  this.annotation.setArguments(list);
  pm.pushParser(new ExpressionListParser(list));
}
this.mode=PARAMETERS_END;
return;
}
pm.popParser(true);
return;
case PARAMETERS_END:
if (type == Symbols.CLOSE_PARENTHESIS) {
pm.popParser();
return;
}
pm.report(token,"String_Node_Str");
return;
}
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token){
  int type=token.type();
switch (this.mode) {
case NAME:
    if (ParserUtil.isIdentifier(type)) {
      Name name=token.nameValue();
      ICodePosition position=token.raw();
      this.annotation.setPosition(position);
      this.annotation.setType(new NamedType(position,name));
      this.mode=PARAMETERS_START;
      return;
    }
  pm.report(token,"String_Node_Str");
return;
case PARAMETERS_START:
if (type == Symbols.OPEN_PARENTHESIS) {
IToken next=token.next();
if (ParserUtil.isIdentifier(next.type()) && next.next().type() == Symbols.COLON) {
  ArgumentMap map=new ArgumentMap();
  this.annotation.setArguments(map);
  pm.pushParser(new ExpressionMapParser(map));
}
 else {
  ArgumentList list=new ArgumentList();
  this.annotation.setArguments(list);
  pm.pushParser(new ExpressionListParser(list));
}
this.mode=PARAMETERS_END;
return;
}
pm.popParser(true);
return;
case PARAMETERS_END:
if (type == Symbols.CLOSE_PARENTHESIS) {
pm.popParser();
return;
}
pm.report(token,"String_Node_Str");
return;
}
}
Program: 83066
Project: 83066
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Class.bodyStart).append('\n');
  String prefix1=prefix + Formatting.Class.bodyIndent;
  if (this.classCount > 0) {
    for (int i=0; i < this.classCount; i++) {
      this.classes[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.classCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.fieldCount > 0) {
    for (int i=0; i < this.fieldCount; i++) {
      this.fields[i].toString(prefix1,buffer);
      buffer.append('\n');
    }
    buffer.append('\n');
  }
  if (this.constructorCount > 0) {
    for (int i=0; i < this.constructorCount; i++) {
      this.constructors[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.constructorCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.propertyCount > 0) {
    for (int i=0; i < this.propertyCount; i++) {
      this.properties[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.propertyCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.methodCount > 0) {
    for (int i=0; i < this.methodCount; i++) {
      IMethod method=this.methods[i];
      method.toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.methodCount) {
        buffer.append('\n');
      }
    }
  }
  buffer.append(prefix).append(Formatting.Class.bodyEnd);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Class.bodyStart).append('\n');
  String prefix1=prefix + Formatting.Class.bodyIndent;
  if (this.classCount > 0) {
    for (int i=0; i < this.classCount; i++) {
      this.classes[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.classCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.fieldCount > 0) {
    for (int i=0; i < this.fieldCount; i++) {
      this.fields[i].toString(prefix1,buffer);
      buffer.append(';').append('\n');
    }
    buffer.append('\n');
  }
  if (this.constructorCount > 0) {
    for (int i=0; i < this.constructorCount; i++) {
      this.constructors[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.constructorCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.propertyCount > 0) {
    for (int i=0; i < this.propertyCount; i++) {
      this.properties[i].toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.propertyCount) {
        buffer.append('\n');
      }
    }
    buffer.append('\n');
  }
  if (this.methodCount > 0) {
    for (int i=0; i < this.methodCount; i++) {
      IMethod method=this.methods[i];
      method.toString(prefix1,buffer);
      buffer.append('\n');
      if (i + 1 < this.methodCount) {
        buffer.append('\n');
      }
    }
  }
  buffer.append(prefix).append(Formatting.Class.bodyEnd);
}
Program: 83067
Project: 83067
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.FIELD.toString(this.modifiers));
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ');
  buffer.append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    this.value.toString(prefix,buffer);
  }
  buffer.append(';');
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.FIELD.toString(this.modifiers));
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ');
  buffer.append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    this.value.toString(prefix,buffer);
  }
}
Program: 83068
Project: 83068
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.METHOD.toString(this.modifiers));
  if (this.type != null) {
    this.type.toString("String_Node_Str",buffer);
    buffer.append(' ');
  }
  buffer.append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  buffer.append(Formatting.Method.parametersStart);
  Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
  buffer.append(Formatting.Method.parametersEnd);
  if (this.exceptionCount > 0) {
    buffer.append(Formatting.Method.signatureThrowsSeperator);
    Util.astToString(prefix,this.exceptions,this.exceptionCount,Formatting.Method.throwsSeperator,buffer);
  }
  if (this.value == null) {
    buffer.append(';');
    return;
  }
  if (this.value.valueTag() != IValue.STATEMENT_LIST) {
    buffer.append(Formatting.Method.signatureBodySeperator);
    this.value.toString(prefix,buffer);
    buffer.append(';');
    return;
  }
  if (((StatementList)this.value).isEmpty()) {
    buffer.append(Formatting.Method.emptyBody);
    return;
  }
  buffer.append(' ');
  this.value.toString(prefix,buffer);
  return;
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.METHOD.toString(this.modifiers));
  if (this.type != null) {
    this.type.toString("String_Node_Str",buffer);
    buffer.append(' ');
  }
  buffer.append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  buffer.append(Formatting.Method.parametersStart);
  Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
  buffer.append(Formatting.Method.parametersEnd);
  if (this.exceptionCount > 0) {
    buffer.append(Formatting.Method.signatureThrowsSeperator);
    Util.astToString(prefix,this.exceptions,this.exceptionCount,Formatting.Method.throwsSeperator,buffer);
  }
  if (this.value == null) {
    buffer.append(';');
    return;
  }
  if (this.value.valueTag() != IValue.STATEMENT_LIST) {
    buffer.append(Formatting.Method.signatureBodySeperator);
    this.value.toString(prefix,buffer);
    buffer.append(';');
    return;
  }
  if (((StatementList)this.value).isEmpty()) {
    buffer.append(Formatting.Method.emptyBody);
    return;
  }
  buffer.append(' ');
  this.value.toString(prefix,buffer);
}
Program: 83069
Project: 83069
Buggy source:
@Override public void addMethod(IMethod method){
  REPLMemberClass iclass=REPLContext.getREPLClass(method);
  method.resolveTypes(markers,this);
  if (reportErrors(markers)) {
    this.cleanup();
    return;
  }
  methods.add(method);
  method.resolve(markers,this);
  method.checkTypes(markers,this);
  method.check(markers,this);
  if (reportErrors(markers)) {
    this.cleanup();
    return;
  }
  method.foldConstants();
  method.cleanup(this,this);
  REPLContext.compileClass(iclass);
  StringBuilder buf=new StringBuilder("String_Node_Str");
  Util.methodSignatureToString(method,buf);
  System.out.println(buf.append('\'').toString());
  this.cleanup();
}

Fixed version (ground truth):
@Override public void addMethod(IMethod method){
  REPLMemberClass iclass=REPLContext.getREPLClass(method);
  method.resolveTypes(markers,this);
  if (reportErrors(markers)) {
    this.cleanup();
    return;
  }
  methods.add(method);
  method.resolve(markers,this);
  method.checkTypes(markers,this);
  method.check(markers,this);
  if (reportErrors(markers)) {
    methods.remove(method);
    this.cleanup();
    return;
  }
  method.foldConstants();
  method.cleanup(this,this);
  REPLContext.compileClass(iclass);
  StringBuilder buf=new StringBuilder("String_Node_Str");
  Util.methodSignatureToString(method,buf);
  System.out.println(buf.append('\'').toString());
  this.cleanup();
}
Program: 83070
Project: 83070
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 || 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;
}

Fixed version (ground truth):
public boolean parse(MarkerList markers,TokenIterator tokens,Parser parser){
  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();
  super.parse(tokens);
  return !this.syntaxErrors;
}
Program: 83071
Project: 83071
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount == 1) {
    return this.values[0].withType(type,typeContext,markers,context);
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralExpression(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  IClass tupleClass=TupleType.getTupleClass(this.valueCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  IClass iclass=type.getTheClass();
  for (int i=0; i < this.valueCount; i++) {
    IType elementType=type.resolveTypeSafely(iclass.getTypeVariable(i));
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker m=markers.create(value.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + value.getType());
      m.addInfo("String_Node_Str" + elementType);
    }
 else {
      this.values[i]=value=value1;
    }
  }
  this.tupleType=this.getType();
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount == 1) {
    return this.values[0].withType(type,typeContext,markers,context);
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralExpression(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  IClass tupleClass=TupleType.getTupleClass(this.valueCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  IClass iclass=type.getTheClass();
  for (int i=0; i < this.valueCount; i++) {
    IType elementType=iclass == dyvil.tools.compiler.ast.type.Types.OBJECT_CLASS ? dyvil.tools.compiler.ast.type.Types.ANY : type.resolveTypeSafely(iclass.getTypeVariable(i));
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker m=markers.create(value.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + value.getType());
      m.addInfo("String_Node_Str" + elementType);
    }
 else {
      this.values[i]=value=value1;
    }
  }
  this.tupleType=this.getType();
  return this;
}
Program: 83072
Project: 83072
Buggy source:
protected static Class loadClass(String name,byte[] bytes){
  if (DyvilREPL.dumpDir != null) {
    int index=name.lastIndexOf('/');
    String fileName;
    if (index <= 0) {
      fileName=name + "String_Node_Str";
    }
 else {
      fileName=name.substring(index + 1) + "String_Node_Str";
    }
    FileUtils.write(new File(DyvilREPL.dumpDir,fileName),bytes);
  }
  return ReflectUtils.unsafe.defineClass(name,bytes,0,bytes.length,CLASS_LOADER,PROTECTION_DOMAIN);
}

Fixed version (ground truth):
protected static Class loadClass(String name,byte[] bytes){
  if (DyvilREPL.dumpDir != null) {
    int index=name.lastIndexOf('/');
    String fileName;
    if (index <= 0) {
      fileName=name + "String_Node_Str";
    }
 else {
      fileName=name.substring(index + 1) + "String_Node_Str";
    }
    FileUtils.write(new File(DyvilREPL.dumpDir,fileName),bytes);
  }
  return ReflectUtils.unsafe.defineClass(name.replace('/','.'),bytes,0,bytes.length,CLASS_LOADER,PROTECTION_DOMAIN);
}
Program: 83073
Project: 83073
Buggy source:
public IdentityHashMap(AbstractIdentityHashMap<K,V> map){
  super(map);
}

Fixed version (ground truth):
public IdentityHashMap(Tuple2<K,V>... entries){
  super(entries);
}
Program: 83074
Project: 83074
Buggy source:
@Override public String toString(){
  if (this.size == 0) {
    return "String_Node_Str";
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  int i=0;
  Object[] tab=this.table;
  for (; i < tab.length; i+=2) {
    Object key=tab[i];
    if (key != null) {
      builder.append(key).append("String_Node_Str").append(tab[i + 1]);
      break;
    }
  }
  for (i+=2; i < tab.length; i+=2) {
    Object key=tab[i];
    if (key != null) {
      builder.append("String_Node_Str").append(key).append("String_Node_Str").append(tab[i + 1]);
    }
  }
  return builder.append("String_Node_Str").toString();
}

Fixed version (ground truth):
@Override public String toString(){
  if (this.size == 0) {
    return "String_Node_Str";
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  int i=0;
  Object[] tab=this.table;
  for (; i < tab.length; i+=2) {
    Object key=tab[i];
    if (key != null) {
      builder.append(unmaskNull(key)).append("String_Node_Str").append(tab[i + 1]);
      break;
    }
  }
  for (i+=2; i < tab.length; i+=2) {
    Object key=tab[i];
    if (key != null) {
      builder.append("String_Node_Str").append(key).append("String_Node_Str").append(tab[i + 1]);
    }
  }
  return builder.append("String_Node_Str").toString();
}
Program: 83075
Project: 83075
Buggy source:
@Override public E next(){
  if (!this.indexValid && !this.hasNext()) {
    throw new NoSuchElementException();
  }
  this.indexValid=false;
  this.lastReturnedIndex=this.index;
  this.index++;
  return (E)this.traversalTable[this.lastReturnedIndex];
}

Fixed version (ground truth):
@Override public E next(){
  if (!this.indexValid && !this.hasNext()) {
    throw new NoSuchElementException();
  }
  this.indexValid=false;
  this.lastReturnedIndex=this.index;
  this.index++;
  return (E)unmaskNull(this.traversalTable[this.lastReturnedIndex]);
}
Program: 83076
Project: 83076
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.valueCount == 0) {
    return;
  }
  IContext context1=this.variables == null ? context : new CombiningContext(this,context);
  int len=this.valueCount - 1;
  for (int i=0; i < len; i++) {
    IValue v=this.values[i];
    IValue v1=v.withType(Types.VOID,Types.VOID,markers,context1);
    if (v1 == null) {
      Marker marker=markers.create(v.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + v.getType());
    }
 else {
      v=this.values[i]=v1;
    }
    v.checkTypes(markers,context1);
  }
  IValue lastValue=this.values[len];
  IType type=this.returnType == null ? lastValue.getType() : this.returnType;
  IValue lastValue1=lastValue.withType(type,type,markers,context1);
  if (lastValue1 == null) {
    Marker marker=markers.create(lastValue.getPosition(),"String_Node_Str");
    marker.addInfo("String_Node_Str" + this.returnType);
    marker.addInfo("String_Node_Str" + lastValue.getType());
  }
 else {
    lastValue=lastValue1;
    if (this.returnType == null) {
      this.returnType=lastValue.getType();
    }
  }
  lastValue.checkTypes(markers,context1);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.valueCount == 0) {
    return;
  }
  IContext context1=this.variables == null ? context : new CombiningContext(this,context);
  int len=this.valueCount - 1;
  for (int i=0; i < len; i++) {
    IValue v=this.values[i];
    IValue v1=v.withType(Types.VOID,Types.VOID,markers,context1);
    if (v1 == null) {
      Marker marker=markers.create(v.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + v.getType());
    }
 else {
      v=this.values[i]=v1;
    }
    v.checkTypes(markers,context1);
  }
  this.values[len].checkTypes(markers,context1);
}
Program: 83077
Project: 83077
Buggy source:
public static final Name stripEq(Name name){
  return Name.get(name.qualified.substring(0,name.qualified.length() - 3),name.unqualified.substring(0,name.unqualified.length() - 1));
}

Fixed version (ground truth):
public static final Name stripEq(Name name){
  String qualified=name.qualified.substring(0,name.qualified.length() - 3);
  String unqualified=name.unqualified.substring(0,name.unqualified.length() - 1);
  return Name.get(qualified,unqualified);
}
Program: 83079
Project: 83079
Buggy source:
@Override protected IValue resolveCall(MarkerList markers,IContext context){
  int args=this.arguments.size();
  if (args == 1) {
    IValue op;
    if (this.instance != null) {
      op=Operators.getPriority(this.instance,this.name,this.arguments.getFirstValue());
    }
 else {
      op=Operators.getPriority(this.name,this.arguments.getFirstValue());
    }
    if (op != null) {
      op.setPosition(this.position);
      return op;
    }
  }
  IMethod method=ICall.resolveMethod(context,this.instance,this.name,this.arguments);
  if (method != null) {
    this.method=method;
    this.checkArguments(markers,context);
    return this;
  }
  if (args == 1 && this.instance != null) {
    String qualified=this.name.qualified;
    if (qualified.endsWith("String_Node_Str")) {
      Name name=ExpressionParser.stripEq(this.name);
      CompoundCall cc=new CompoundCall(this.position,this.instance,name,this.arguments);
      return cc.resolveCall(markers,context);
    }
    IValue op=Operators.get(this.instance,this.name,this.arguments.getFirstValue());
    if (op != null) {
      op.setPosition(this.position);
      return op;
    }
  }
  if (this.instance == null) {
    AbstractCall apply=this.resolveApply(markers,context);
    if (apply != null) {
      apply.checkArguments(markers,context);
      return apply;
    }
  }
  ICall.addResolveMarker(markers,this.position,this.instance,this.name,this.arguments);
  return this;
}

Fixed version (ground truth):
@Override protected IValue resolveCall(MarkerList markers,IContext context){
  int args=this.arguments.size();
  if (args == 1) {
    IValue op;
    if (this.instance != null) {
      op=Operators.getPriority(this.instance,this.name,this.arguments.getFirstValue());
    }
 else {
      op=Operators.getPriority(this.name,this.arguments.getFirstValue());
    }
    if (op != null) {
      op.setPosition(this.position);
      return op;
    }
  }
  IMethod method=ICall.resolveMethod(context,this.instance,this.name,this.arguments);
  if (method != null) {
    this.method=method;
    this.checkArguments(markers,context);
    return this;
  }
  if (args == 1 && this.instance != null) {
    String qualified=this.name.qualified;
    if (qualified.endsWith("String_Node_Str")) {
      Name name=Util.stripEq(this.name);
      CompoundCall cc=new CompoundCall(this.position,this.instance,name,this.arguments);
      return cc.resolveCall(markers,context);
    }
    IValue op=Operators.get(this.instance,this.name,this.arguments.getFirstValue());
    if (op != null) {
      op.setPosition(this.position);
      return op;
    }
  }
  if (this.instance == null) {
    AbstractCall apply=this.resolveApply(markers,context);
    if (apply != null) {
      apply.checkArguments(markers,context);
      return apply;
    }
  }
  ICall.addResolveMarker(markers,this.position,this.instance,this.name,this.arguments);
  return this;
}
Program: 83080
Project: 83080
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  if (this.theClass == null) {
    return;
  }
  if (this.retention == null) {
    IAnnotation retention=this.theClass.getAnnotation(Annotation.Types.RETENTION_CLASS);
    if (retention != null) {
      INamed value=(INamed)retention.getArguments().getValue(0,Annotation.VALUE);
      this.retention=RetentionPolicy.valueOf(value.getName().qualified);
    }
  }
  if (this.targets != null) {
    return;
  }
  IAnnotation target=this.theClass.getAnnotation(Annotation.Types.TARGET_CLASS);
  if (target == null) {
    return;
  }
  this.targets=new TreeSet();
  IValueList values=(IValueList)target.getArguments().getValue(0,Annotation.VALUE);
  if (values == null) {
    return;
  }
  int count=values.valueCount();
  for (int i=0; i < count; i++) {
    INamed value=(INamed)values.getValue(i);
    this.targets.add(ElementType.valueOf(value.getName().qualified));
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  if (this.theClass == null) {
    return;
  }
  if (this.retention == null) {
    IAnnotation retention=this.theClass.getAnnotation(Annotation.Types.RETENTION_CLASS);
    if (retention != null) {
      INamed value=(INamed)retention.getArguments().getValue(0,Annotation.VALUE);
      try {
        this.retention=RetentionPolicy.valueOf(value.getName().qualified);
      }
 catch (      IllegalArgumentException ex) {
      }
    }
  }
  if (this.targets != null) {
    return;
  }
  IAnnotation target=this.theClass.getAnnotation(Annotation.Types.TARGET_CLASS);
  if (target == null) {
    return;
  }
  this.targets=new TreeSet();
  IValueList values=(IValueList)target.getArguments().getValue(0,Annotation.VALUE);
  if (values == null) {
    return;
  }
  int count=values.valueCount();
  for (int i=0; i < count; i++) {
    INamed value=(INamed)values.getValue(i);
    ElementType elementType;
    try {
      elementType=ElementType.valueOf(value.getName().qualified);
    }
 catch (    IllegalArgumentException ex) {
      continue;
    }
    this.targets.add(elementType);
  }
}
Program: 83081
Project: 83081
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.annotations != null) {
    this.annotations.toString();
  }
  buffer.append(prefix).append(ModifierTypes.CLASS.toString(this.modifiers));
  buffer.append(ModifierTypes.CLASS_TYPE.toString(this.modifiers)).append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  if (this.parameterCount > 0) {
    buffer.append('(');
    Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
    buffer.append(')');
  }
  if (this.superType == null) {
    buffer.append("String_Node_Str");
  }
 else   if (this.superType != Types.OBJECT) {
    buffer.append("String_Node_Str");
    this.superType.toString("String_Node_Str",buffer);
  }
  if (this.interfaceCount > 0) {
    buffer.append("String_Node_Str");
    Util.astToString(prefix,this.interfaces,this.interfaceCount,Formatting.Class.superClassesSeperator,buffer);
  }
  if (this.body != null) {
    buffer.append('\n').append(prefix);
    this.body.toString(prefix,buffer);
  }
 else {
    buffer.append(';');
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.annotations != null) {
    this.annotations.toString(prefix,buffer);
  }
  buffer.append(prefix).append(ModifierTypes.CLASS.toString(this.modifiers));
  buffer.append(ModifierTypes.CLASS_TYPE.toString(this.modifiers)).append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  if (this.parameterCount > 0) {
    buffer.append('(');
    Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
    buffer.append(')');
  }
  if (this.superType == null) {
    buffer.append("String_Node_Str");
  }
 else   if (this.superType != Types.OBJECT) {
    buffer.append("String_Node_Str");
    this.superType.toString("String_Node_Str",buffer);
  }
  if (this.interfaceCount > 0) {
    buffer.append("String_Node_Str");
    Util.astToString(prefix,this.interfaces,this.interfaceCount,Formatting.Class.superClassesSeperator,buffer);
  }
  if (this.body != null) {
    buffer.append('\n').append(prefix);
    this.body.toString(prefix,buffer);
  }
 else {
    buffer.append(';');
  }
}
Program: 83082
Project: 83082
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.CLASS);
  IClass iclass=this.type.getTheClass();
  this.getter=context.getAccessibleThis(iclass);
  if (this.getter == null) {
    markers.add(this.position,"String_Node_Str",iclass.getFullName());
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.type == Types.UNKNOWN) {
    return;
  }
  this.type.checkType(markers,context,TypePosition.CLASS);
  IClass iclass=this.type.getTheClass();
  this.getter=context.getAccessibleThis(iclass);
  if (this.getter == null) {
    markers.add(this.position,"String_Node_Str",this.type);
  }
}
Program: 83083
Project: 83083
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (context.isStatic()) {
    markers.add(this.position,"String_Node_Str");
  }
  if (this.type == Types.UNKNOWN) {
    this.type=context.getThisClass().getType();
  }
 else {
    this.type=this.type.resolveType(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (context.isStatic()) {
    markers.add(this.position,"String_Node_Str");
    if (this.type == Types.UNKNOWN) {
      return;
    }
  }
  if (this.type != Types.UNKNOWN) {
    this.type=this.type.resolveType(markers,context);
    return;
  }
  IType t=context.getThisClass().getType();
  if (t != null) {
    this.type=t;
  }
}
Program: 83084
Project: 83084
Buggy source:
/** 
 * Removes all elements of the given   {@code collection} from this collectionand adds those that are not currently present in this collection.
 * @param collection the collection to XOR with
 */
public default void $up$eq(Collection<? extends E> collection){
  this.intersect(collection);
}

Fixed version (ground truth):
/** 
 * Removes all elements of the given   {@code collection} from this collectionand adds those that are not currently present in this collection.
 * @param collection the collection to XOR with
 */
public default void $up$eq(Collection<? extends E> collection){
  this.exclusiveOr(collection);
}
Program: 83085
Project: 83085
Buggy source:
public default boolean exclusiveOr(Collection<? extends E> collection){
  boolean changed=false;
  for (  E element : collection) {
    if (!this.contains(element)) {
      this.$plus$eq(element);
      changed=true;
    }
  }
  for (  E element : this) {
    if (!collection.contains(element)) {
      this.$minus$eq(element);
      changed=true;
    }
  }
  return changed;
}

Fixed version (ground truth):
public default boolean exclusiveOr(Collection<? extends E> collection){
  boolean changed=false;
  for (  E element : collection) {
    if (!this.contains(element)) {
      this.remove(element);
      changed=true;
    }
  }
  for (  E element : this) {
    if (!collection.contains(element)) {
      this.remove(element);
      changed=true;
    }
  }
  return changed;
}
Program: 83086
Project: 83086
Buggy source:
@Override public java.util.Set<E> toJava(){
  java.util.Set<E> set=new java.util.HashSet<E>();
  for (  E element : this) {
    set.add(element);
  }
  return set;
}

Fixed version (ground truth):
@Override public java.util.Set<E> toJava(){
  return java.util.Collections.unmodifiableSet(super.toJava());
}
Program: 83087
Project: 83087
Buggy source:
@Override public Iterator<E> iterator(){
  return this.map().keyIterator();
}

Fixed version (ground truth):
@Override public Iterator<E> iterator(){
  return AbstractMapBasedSet.this.map().keyIterator();
}
Program: 83088
Project: 83088
Buggy source:
@Override public boolean contains(Object element){
  return this.map().containsKey(element);
}

Fixed version (ground truth):
@Override public boolean contains(Object o){
  return AbstractMapBasedSet.this.map().containsKey(o);
}
Program: 83089
Project: 83089
Buggy source:
@Override public int size(){
  return this.map().size();
}

Fixed version (ground truth):
@Override public int size(){
  return AbstractMapBasedSet.this.map().size();
}
Program: 83090
Project: 83090
Buggy source:
@Override public java.util.Set<E> toJava(){
  return Collections.newSetFromMap((java.util.Map)this.map().toJava());
}

Fixed version (ground truth):
@Override public java.util.Set<E> toJava(){
  return new java.util.AbstractSet<E>(){
    @Override public int size(){
      return AbstractMapBasedSet.this.map().size();
    }
    @Override public Iterator<E> iterator(){
      return AbstractMapBasedSet.this.map().keyIterator();
    }
    @Override public boolean contains(    Object o){
      return AbstractMapBasedSet.this.map().containsKey(o);
    }
    @Override public boolean add(    E e){
      return AbstractMapBasedSet.this.map().put(e,VALUE) == null;
    }
    @Override public boolean remove(    Object o){
      return AbstractMapBasedSet.this.map().removeKey(o) != null;
    }
  }
;
}
Program: 83091
Project: 83091
Buggy source:
@Override public ImmutableList<E> immutable(){
  return new ArrayList(this);
}

Fixed version (ground truth):
@Override public ImmutableList<E> immutable(){
  return ImmutableList.linked(this);
}
Program: 83092
Project: 83092
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.writeStatement(writer);
}
Program: 83093
Project: 83093
Buggy source:
@Override protected IValue resolveCall(MarkerList markers,IContext context){
  int type=this.instance.valueTag();
  if (type == APPLY_CALL) {
    AbstractCall ac=(AbstractCall)this.instance;
    IValue op=new MethodCall(this.position,ac,this.name,this.arguments).resolveCall(markers,context);
    IValue update=new UpdateMethodCall(this.position,ac.instance,ac.arguments.withLastValue(Name.update,op)).resolveCall(markers,context);
    return update;
  }
 else   if (type == SUBSCRIPT_GET) {
    AbstractCall ac=(AbstractCall)this.instance;
    IValue op=new MethodCall(this.position,ac,this.name,this.arguments).resolveCall(markers,context);
    IValue subscript_$eq=new SubscriptSetter(this.position,ac.instance,ac.arguments.withLastValue(Name.subscript_$eq,op)).resolveCall(markers,context);
    return subscript_$eq;
  }
 else   if (type != FIELD_ACCESS) {
    throw new Error();
  }
  IMethod m=this.method=ICall.resolveMethod(context,this.instance,this.name,this.arguments);
  if (m == null) {
    ICall.addResolveMarker(markers,position,instance,name,arguments);
  }
  return this;
}

Fixed version (ground truth):
@Override protected IValue resolveCall(MarkerList markers,IContext context){
  int type=this.instance.valueTag();
  if (type == APPLY_CALL) {
    AbstractCall ac=(AbstractCall)this.instance;
    IValue op=new MethodCall(this.position,ac,this.name,this.arguments).resolveCall(markers,context);
    IValue update=new UpdateMethodCall(this.position,ac.instance,ac.arguments.withLastValue(Name.update,op)).resolveCall(markers,context);
    return update;
  }
 else   if (type == SUBSCRIPT_GET) {
    AbstractCall ac=(AbstractCall)this.instance;
    IValue op=new MethodCall(this.position,ac,this.name,this.arguments).resolveCall(markers,context);
    IValue subscript_$eq=new SubscriptSetter(this.position,ac.instance,ac.arguments.withLastValue(Name.subscript_$eq,op)).resolveCall(markers,context);
    return subscript_$eq;
  }
 else   if (type != FIELD_ACCESS) {
    throw new Error();
  }
  IMethod m=this.method=ICall.resolveMethod(context,this.instance,this.name,this.arguments);
  if (m == null) {
    ICall.addResolveMarker(markers,this.position,this.instance,this.name,this.arguments);
  }
  return this;
}
Program: 83094
Project: 83094
Buggy source:
@Override public int valueTag(){
  return METHOD_CALL;
}

Fixed version (ground truth):
@Override public int valueTag(){
  return COMPOUND_CALL;
}