nus-yam/ex-repair huggingface dataset:
Program: 84370
Project: 84370
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: 84371
Project: 84371
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: 84372
Project: 84372
Buggy source:
public IdentityHashMap(AbstractIdentityHashMap<K,V> map){
  super(map);
}

Fixed version (ground truth):
public IdentityHashMap(Tuple2<K,V>... entries){
  super(entries);
}
Program: 84373
Project: 84373
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: 84374
Project: 84374
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: 84375
Project: 84375
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: 84376
Project: 84376
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: 84378
Project: 84378
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: 84379
Project: 84379
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: 84380
Project: 84380
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: 84381
Project: 84381
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: 84382
Project: 84382
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: 84383
Project: 84383
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: 84384
Project: 84384
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: 84385
Project: 84385
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: 84386
Project: 84386
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: 84387
Project: 84387
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: 84388
Project: 84388
Buggy source:
@Override public int size(){
  return this.map().size();
}

Fixed version (ground truth):
@Override public int size(){
  return AbstractMapBasedSet.this.map().size();
}
Program: 84389
Project: 84389
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: 84390
Project: 84390
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: 84391
Project: 84391
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: 84392
Project: 84392
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: 84393
Project: 84393
Buggy source:
@Override public int valueTag(){
  return METHOD_CALL;
}

Fixed version (ground truth):
@Override public int valueTag(){
  return COMPOUND_CALL;
}
Program: 84394
Project: 84394
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.arguments.resolve(markers,context);
  if (!this.type.isResolved()) {
    return this;
  }
  if (this.type.isArrayType()) {
    int len=this.arguments.size();
    int dims=this.type.getArrayDimensions();
    if (dims != len) {
      Marker marker=markers.create(this.position,"String_Node_Str");
      marker.addInfo("String_Node_Str" + dims);
      marker.addInfo("String_Node_Str" + len);
      return this;
    }
    if (!(this.arguments instanceof ArgumentList)) {
      markers.add(this.position,"String_Node_Str");
      return this;
    }
    ArgumentList paramList=(ArgumentList)this.arguments;
    for (int i=0; i < len; i++) {
      IValue v=paramList.getValue(i);
      IValue v1=v.withType(Types.INT,Types.INT,markers,context);
      if (v1 == null) {
        Marker marker=markers.create(v.getPosition(),"String_Node_Str");
        marker.addInfo("String_Node_Str" + v.getType());
      }
 else {
        paramList.setValue(i,v1);
      }
    }
    return this;
  }
  this.constructor=IContext.resolveConstructor(this.type,this.arguments);
  if (this.constructor == null) {
    this.reportResolve(markers);
    return this;
  }
  if (this.constructor.getTheClass().isGeneric() && !this.type.isGenericType()) {
    this.type=this.constructor.checkGenericType(markers,position,context,type,arguments);
  }
  this.constructor.checkArguments(markers,this.position,context,this.type,this.arguments);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.arguments.resolve(markers,context);
  if (!this.type.isResolved()) {
    return this;
  }
  if (this.type.isArrayType()) {
    int len=this.arguments.size();
    int dims=this.type.getArrayDimensions();
    if (dims != len) {
      Marker marker=markers.create(this.position,"String_Node_Str");
      marker.addInfo("String_Node_Str" + dims);
      marker.addInfo("String_Node_Str" + len);
      return this;
    }
    if (!(this.arguments instanceof ArgumentList)) {
      markers.add(this.position,"String_Node_Str");
      return this;
    }
    ArgumentList paramList=(ArgumentList)this.arguments;
    for (int i=0; i < len; i++) {
      IValue v=paramList.getValue(i);
      IValue v1=v.withType(Types.INT,Types.INT,markers,context);
      if (v1 == null) {
        Marker marker=markers.create(v.getPosition(),"String_Node_Str");
        marker.addInfo("String_Node_Str" + v.getType());
      }
 else {
        paramList.setValue(i,v1);
      }
    }
    return this;
  }
  this.constructor=IContext.resolveConstructor(this.type,this.arguments);
  if (this.constructor == null) {
    this.reportResolve(markers);
    return this;
  }
  if (this.constructor.getTheClass().isGeneric() && !this.type.isGenericType()) {
    this.type=this.constructor.checkGenericType(markers,this.position,context,this.type,this.arguments);
  }
  this.constructor.checkArguments(markers,this.position,context,this.type,this.arguments);
  return this;
}
Program: 84395
Project: 84395
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  this.arguments.resolve(markers,context);
  IClass theClass=this.type.getTheClass();
  if (theClass == null) {
    return;
  }
  int count=theClass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=theClass.getParameter(i);
    IType type=param.getType();
    IValue value=this.arguments.getValue(i,param);
    if (value == null) {
      if (param.getValue() == null) {
        markers.add(this.position,"String_Node_Str",this.type,param.getName());
      }
      continue;
    }
    IValue value1=value.withType(type,type,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str",param.getName());
      marker.addInfo("String_Node_Str" + type);
      marker.addInfo("String_Node_Str" + value.getType());
      continue;
    }
    value1=Util.constant(value1,markers);
    if (value1 != value) {
      this.arguments.setValue(i,param,value1);
    }
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  this.arguments.resolve(markers,context);
  IClass theClass=this.type.getTheClass();
  if (theClass == null) {
    return;
  }
  int count=theClass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=theClass.getParameter(i);
    IType type=param.getType();
    IValue value=this.arguments.getValue(i,param);
    if (value == null) {
      if (param.getValue() == null) {
        markers.add(this.position,"String_Node_Str",this.type,param.getName());
      }
      continue;
    }
    IValue value1=value.withType(type,type,markers,context);
    if (value1 == null) {
      Util.createTypeError(markers,value,type,type,"String_Node_Str",param.getName());
      continue;
    }
    value1=Util.constant(value1,markers);
    if (value1 != value) {
      this.arguments.setValue(i,param,value1);
    }
  }
}
Program: 84396
Project: 84396
Buggy source:
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  this.value=this.value.cleanup(context,compilableList);
  if (this.capturedFieldCount == 0) {
    if (this.value instanceof AbstractCall) {
      AbstractCall c=(AbstractCall)this.value;
      IMethod method=c.getMethod();
      if (this.checkCall(c.getValue(),c.getArguments(),method)) {
switch (method.getInvokeOpcode()) {
case Opcodes.INVOKEVIRTUAL:
          this.directInvokeOpcode=ClassFormat.H_INVOKEVIRTUAL;
        break;
case Opcodes.INVOKESTATIC:
      this.directInvokeOpcode=ClassFormat.H_INVOKESTATIC;
    break;
case Opcodes.INVOKEINTERFACE:
  this.directInvokeOpcode=ClassFormat.H_INVOKEINTERFACE;
break;
case Opcodes.INVOKESPECIAL:
this.directInvokeOpcode=ClassFormat.H_INVOKESPECIAL;
break;
}
this.name=method.getName().qualified;
this.owner=method.getTheClass().getInternalName();
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 (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: 84397
Project: 84397
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IMethod method=this.method;
  if (method == null) {
    method=IContext.resolveMethod(type,null,this.methodName,this.arguments);
    if (method == null) {
      StringBuilder builder=new StringBuilder();
      this.arguments.typesToString(builder);
      markers.add(this.literal.getPosition(),"String_Node_Str",this.literal.getType(),type,builder);
      this.type=type;
      return null;
    }
    this.method=method;
  }
  GenericData data=method.getGenericData(null,null,this.arguments);
  method.checkArguments(markers,this.literal.getPosition(),context,null,this.arguments,data);
  this.type=method.getType().getConcreteType(data);
  if (!type.isSuperTypeOf(this.type)) {
    Marker m=markers.create(this.literal.getPosition(),"String_Node_Str");
    m.addInfo("String_Node_Str" + type);
    m.addInfo("String_Node_Str" + this.type);
    StringBuilder sb=new StringBuilder("String_Node_Str");
    Util.methodSignatureToString(method,sb);
    m.addInfo(sb.toString());
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IMethod method=this.method;
  if (method == null) {
    method=IContext.resolveMethod(type,null,this.methodName,this.arguments);
    if (method == null) {
      StringBuilder builder=new StringBuilder();
      this.arguments.typesToString(builder);
      markers.add(this.literal.getPosition(),"String_Node_Str",this.literal.getType(),type,builder);
      this.type=type;
      return null;
    }
    this.method=method;
  }
  GenericData data=method.getGenericData(null,null,this.arguments);
  method.checkArguments(markers,this.literal.getPosition(),context,null,this.arguments,data);
  this.type=method.getType().getConcreteType(data);
  if (!type.isSuperTypeOf(this.type)) {
    Marker m=markers.create(this.literal.getPosition(),"String_Node_Str");
    m.addInfo("String_Node_Str" + type.getConcreteType(typeContext));
    m.addInfo("String_Node_Str" + this.type);
    StringBuilder sb=new StringBuilder("String_Node_Str");
    Util.methodSignatureToString(method,sb);
    m.addInfo(sb.toString());
  }
  return this;
}
Program: 84399
Project: 84399
Buggy source:
/** 
 * Determines whether to generate a   {@code tableswitch} or a{@code lookupswitch} instruction, and returns {@code true} when a{@code tableswitch} should be generated.
 * @param low the lowest value
 * @param high the highest value
 * @param count the number of cases
 * @return true, if a tableswitch instruction should be used
 */
private static boolean useTableSwitch(int low,int high,int count){
  int tableSpace=4 + (high - low + 1);
  int tableTime=3;
  int lookupSpace=3 + 2 * count;
  int lookupTime=MathUtils.logBaseTwo(count);
  return count > 0 && tableSpace + 3 * tableTime <= lookupSpace + 3 * lookupTime;
}

Fixed version (ground truth):
/** 
 * Determines whether to generate a   {@code tableswitch} or a{@code lookupswitch} instruction, and returns {@code true} when a{@code tableswitch} should be generated.
 * @param low the lowest value
 * @param high the highest value
 * @param count the number of cases
 * @return true, if a tableswitch instruction should be used
 */
private static boolean useTableSwitch(int low,int high,int count){
  int tableSpace=4 + high - low + 1;
  int tableTime=3;
  int lookupSpace=3 + 2 * count;
  int lookupTime=MathUtils.logBaseTwo(count);
  return count > 0 && tableSpace + 3 * tableTime <= lookupSpace + 3 * lookupTime;
}
Program: 84400
Project: 84400
Buggy source:
@Override public void foldConstants(){
  if (this.bound != null)   this.bound.foldConstants();
}

Fixed version (ground truth):
@Override public void foldConstants(){
  if (this.bound != null) {
    this.bound.foldConstants();
  }
}
Program: 84401
Project: 84401
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.bound != null)   this.bound.check(markers,context);
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.bound != null) {
    this.bound.check(markers,context);
  }
}
Program: 84402
Project: 84402
Buggy source:
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  if (this.bound != null)   this.bound.cleanup(context,compilableList);
}

Fixed version (ground truth):
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  if (this.bound != null) {
    this.bound.cleanup(context,compilableList);
  }
}
Program: 84403
Project: 84403
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  if (this.type != null)   this.type.resolve(markers,context);
  if (this.annotations != null) {
    this.annotations.resolve(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.resolve(markers,context);
  }
  if (this.annotations != null) {
    this.annotations.resolve(markers,context);
  }
}
Program: 84404
Project: 84404
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.type != null)   this.type.checkType(markers,context,TypePosition.RETURN_TYPE);
  if (this.annotations != null) {
    this.annotations.checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.checkType(markers,context,TypePosition.RETURN_TYPE);
  }
  if (this.annotations != null) {
    this.annotations.checkTypes(markers,context);
  }
}
Program: 84405
Project: 84405
Buggy source:
@Override public void foldConstants(){
  if (this.type != null)   this.type.foldConstants();
  if (this.annotations != null) {
    this.annotations.foldConstants();
  }
}

Fixed version (ground truth):
@Override public void foldConstants(){
  if (this.type != null) {
    this.type.foldConstants();
  }
  if (this.annotations != null) {
    this.annotations.foldConstants();
  }
}
Program: 84406
Project: 84406
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.type != null)   this.type.check(markers,context);
  if (this.annotations != null) {
    this.annotations.check(markers,context,this.getElementType());
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.check(markers,context);
  }
  if (this.annotations != null) {
    this.annotations.check(markers,context,this.getElementType());
  }
}
Program: 84407
Project: 84407
Buggy source:
@Override public int getInvokeOpcode(){
  if ((modifiers & Modifiers.STATIC) != 0) {
    return Opcodes.INVOKESTATIC;
  }
  if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    return Opcodes.INVOKESPECIAL;
  }
  if (this.theClass.isInterface()) {
    return Opcodes.INVOKEINTERFACE;
  }
  return Opcodes.INVOKEVIRTUAL;
}

Fixed version (ground truth):
@Override public int getInvokeOpcode(){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    return Opcodes.INVOKESTATIC;
  }
  if ((this.modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    return Opcodes.INVOKESPECIAL;
  }
  if (this.theClass.isInterface()) {
    return Opcodes.INVOKEINTERFACE;
  }
  return Opcodes.INVOKEVIRTUAL;
}
Program: 84409
Project: 84409
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.check(markers,context);
  }
  if (this.method != null) {
    IType type1=this.instance.getType();
    IType type2=this.getType();
    if (!type1.isSuperTypeOf(type2)) {
      Marker marker=markers.create(this.position,"String_Node_Str",this.name,this.instance.toString());
      marker.addInfo("String_Node_Str" + type1);
      marker.addInfo("String_Node_Str" + type2);
    }
    this.method.checkCall(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.check(markers,context);
  }
  if (this.method != null) {
    IType type1=this.instance.getType();
    IType type2=super.getType();
    if (!type1.isSuperTypeOf(type2)) {
      Marker marker=markers.create(this.position,"String_Node_Str",this.name,this.instance.toString());
      marker.addInfo("String_Node_Str" + type1);
      marker.addInfo("String_Node_Str" + type2);
    }
    this.method.checkCall(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}
Program: 84410
Project: 84410
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) {
    return this;
  }
  throw new Error();
}

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,position,instance,name,arguments);
  }
  return this;
}
Program: 84411
Project: 84411
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  if (this.value == null) {
    return;
  }
  if (this.instance == null) {
    this.value.writeExpression(writer,this.field.getTheClass().getType());
    writer.writeInsn(Opcodes.AUTO_DUP);
  }
 else {
    this.instance.writeExpression(writer);
    this.value.writeExpression(writer);
    writer.writeInsn(Opcodes.AUTO_DUP_X1);
  }
  this.field.writeSet(writer,null,null,this.getLineNumber());
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  if (this.instance == null) {
    this.value.writeExpression(writer,this.field.getType());
    writer.writeInsn(Opcodes.AUTO_DUP);
  }
 else {
    this.instance.writeExpression(writer);
    this.value.writeExpression(writer);
    writer.writeInsn(Opcodes.AUTO_DUP_X1);
  }
  this.field.writeSet(writer,null,null,this.getLineNumber());
}
Program: 84412
Project: 84412
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value,int lineNumber) throws BytecodeException {
  if (this.className == null) {
    writer.writeInsn(Opcodes.AUTO_POP);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.PUTSTATIC,this.className,this.name.qualified,extended);
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value,int lineNumber) throws BytecodeException {
  if (value != null) {
    value.writeExpression(writer,this.type);
  }
  if (this.className == null) {
    writer.writeInsn(Opcodes.AUTO_POP);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.PUTSTATIC,this.className,this.name.qualified,extended);
}
Program: 84413
Project: 84413
Buggy source:
@Override public void parse(IParserManager pm,IToken token){
  int type=token.type();
switch (this.mode) {
case OPEN_BRACKET:
    pm.pushParser(new ExpressionParser(this));
  this.mode=SEPARATOR | COLON;
this.startPosition=token;
if (type != Symbols.OPEN_SQUARE_BRACKET) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case SEPARATOR | COLON:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
pm.popParser();
this.end(token);
return;
}
if (type == Symbols.COLON) {
this.mode=SEPARATOR;
this.map=true;
this.values2=new IValue[this.valueCount];
pm.pushParser(new ExpressionParser(this));
return;
}
this.mode=SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COMMA && type != Symbols.SEMICOLON) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case SEPARATOR:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
pm.popParser();
this.end(token);
return;
}
this.mode=this.map ? COLON : SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COMMA && type != Symbols.SEMICOLON) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case COLON:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
this.end(token);
pm.popParser();
return;
}
this.mode=SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COLON) {
pm.reparse();
pm.report(new SyntaxError(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 OPEN_BRACKET:
    pm.pushParser(new ExpressionParser(this));
  this.mode=SEPARATOR | COLON;
this.startPosition=token;
if (type != Symbols.OPEN_SQUARE_BRACKET) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case SEPARATOR | COLON:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
pm.popParser();
this.end(token);
return;
}
if (type == Symbols.COLON) {
this.mode=SEPARATOR;
this.map=true;
this.values2=new IValue[this.valueCount];
pm.pushParser(new ExpressionParser(this));
return;
}
this.mode=SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COMMA && type != Symbols.SEMICOLON) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case SEPARATOR:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
pm.popParser();
this.end(token);
return;
}
this.mode=this.map ? COLON : SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COMMA && type != Symbols.SEMICOLON) {
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
case COLON:
if (type == Symbols.CLOSE_SQUARE_BRACKET) {
this.end(token);
pm.popParser();
return;
}
this.mode=SEPARATOR;
pm.pushParser(new ExpressionParser(this));
if (type != Symbols.COLON) {
pm.reparse();
pm.report(new SyntaxError(token,"String_Node_Str"));
}
return;
}
}
Program: 84414
Project: 84414
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (!this.theClass.isSubTypeOf(Types.ANNOTATION)) {
    this.theClass.addInterface(Types.ANNOTATION);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (!this.theClass.isSubTypeOf(Annotation.Types.ANNOTATION)) {
    this.theClass.addInterface(Annotation.Types.ANNOTATION);
  }
}