nus-yam/ex-repair huggingface dataset:
Program: 83708
Project: 83708
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  if (this.type.isArrayType()) {
    int len=this.arguments.size();
    if (len == 1) {
      this.arguments.getFirstValue().writeExpression(writer);
      this.type.setArrayDimensions(0);
      writer.writeTypeInsn(Opcodes.ANEWARRAY,this.type.getInternalName());
      this.type.setArrayDimensions(1);
      return;
    }
    ArgumentList paramList=(ArgumentList)this.arguments;
    for (int i=0; i < len; i++) {
      paramList.getValue(i).writeExpression(writer);
    }
    writer.writeNewArray(this.type,len);
    return;
  }
  this.constructor.writeCall(writer,this.arguments,null);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  if (this.type.isArrayType()) {
    int len=this.arguments.size();
    if (len == 1) {
      this.arguments.getFirstValue().writeExpression(writer);
      writer.writeNewArray(this.type,1);
      return;
    }
    ArgumentList paramList=(ArgumentList)this.arguments;
    for (int i=0; i < len; i++) {
      paramList.getValue(i).writeExpression(writer);
    }
    writer.writeNewArray(this.type,len);
    return;
  }
  this.constructor.writeCall(writer,this.arguments,null);
}
Program: 83709
Project: 83709
Buggy source:
@Override public void write(ClassWriter writer){
  boolean instance=this.thisClass != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriterImpl(writer,writer.visitMethod(modifiers,this.getName(),this.getLambdaDescriptor(),null,null));
  if (instance) {
    mw.setInstanceMethod();
  }
  int index=0;
  for (int i=0; i < this.capturedFieldCount; i++) {
    CaptureVariable capture=this.capturedFields[i];
    capture.index=index;
    index=mw.registerParameter(index,capture.variable.getName().qualified,capture.variable.getType(),0);
  }
  index=0;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    index=mw.registerParameter(index,param.getName().qualified,param.getType(),0);
    param.setIndex(index);
  }
  mw.begin();
  this.value.writeExpression(mw);
  mw.end(this.returnType);
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer){
  boolean instance=this.thisClass != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriterImpl(writer,writer.visitMethod(modifiers,this.getName(),this.getLambdaDescriptor(),null,null));
  if (instance) {
    mw.setInstanceMethod();
  }
  int index=0;
  for (int i=0; i < this.capturedFieldCount; i++) {
    CaptureVariable capture=this.capturedFields[i];
    capture.index=index;
    index=mw.registerParameter(index,capture.variable.getName().qualified,capture.variable.getType(),0);
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.setIndex(index);
    index=mw.registerParameter(index,param.getName().qualified,param.getType(),0);
  }
  mw.begin();
  this.value.writeExpression(mw);
  mw.end(this.returnType);
}
Program: 83711
Project: 83711
Buggy source:
@Override public IMethod getFunctionalMethod(){
  IMethod m;
  if (this.body != null) {
    m=this.body.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;
  }
  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;
}
Program: 83712
Project: 83712
Buggy source:
@Override public IValue withType(IType type){
  return this.isType(type) ? this : null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type){
  if (this.isType(type)) {
    this.type=type;
    return this;
  }
  return null;
}
Program: 83713
Project: 83713
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.method != null) {
    if (this.method.hasTypeVariables()) {
      for (int i=0; i < this.parameterCount; i++) {
        IParameter param=this.parameters[i];
        param.setType(param.getType().getConcreteType(this.type));
      }
      this.returnType=this.method.getType().getConcreteType(this.type);
    }
 else {
      this.returnType=this.method.getType();
    }
    this.value=this.value.resolve(markers,this);
    IValue value1=this.value.withType(this.returnType);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.returnType);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
    }
  }
 else {
    markers.add(this.position,"String_Node_Str");
  }
  this.value.checkTypes(markers,this);
  this.context=null;
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.method != null) {
    if (this.method.hasTypeVariables()) {
      for (int i=0; i < this.parameterCount; i++) {
        IParameter param=this.parameters[i];
        IType type=param.getType();
        if (type == null) {
          type=this.method.getParameter(i).getType();
        }
        param.setType(type.getConcreteType(this.type));
      }
      this.returnType=this.method.getType().getConcreteType(this.type);
    }
 else {
      this.returnType=this.method.getType();
    }
    this.value=this.value.resolve(markers,this);
    IValue value1=this.value.withType(this.returnType);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.returnType);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
    }
  }
 else {
    markers.add(this.position,"String_Node_Str");
  }
  this.value.checkTypes(markers,this);
  this.context=null;
}
Program: 83714
Project: 83714
Buggy source:
@Override public boolean isType(IType type){
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType paramType=lambdaParam.getType();
    if (paramType == null) {
      lambdaParam.setType(param.getType());
      continue;
    }
    if (!param.getType().equals(paramType)) {
      return false;
    }
  }
  this.type=type;
  this.method=method;
  return true;
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (this.type != null && type.isSuperTypeOf(this.type)) {
    return true;
  }
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType paramType=lambdaParam.getType();
    if (paramType == null) {
      continue;
    }
    if (!param.getType().equals(paramType)) {
      return false;
    }
  }
  this.type=type;
  this.method=method;
  return true;
}
Program: 83715
Project: 83715
Buggy source:
private void resolveSuperTypes(){
  this.superTypesResolved=true;
  if (this.superType != null) {
    this.superType=this.superType.resolve(null,Package.rootPackage);
  }
  for (int i=0; i < this.interfaceCount; i++) {
    this.interfaces[i]=this.interfaces[i].resolve(null,Package.rootPackage);
  }
  if (this.metadata == null) {
    this.metadata=IClass.getClassMetadata(this,this.modifiers);
  }
  this.metadata.resolve(null,Package.rootPackage);
}

Fixed version (ground truth):
private void resolveSuperTypes(){
  this.superTypesResolved=true;
  if (this.superType != null) {
    this.superType=this.superType.resolve(null,this);
  }
  for (int i=0; i < this.interfaceCount; i++) {
    this.interfaces[i]=this.interfaces[i].resolve(null,this);
  }
  if (this.metadata == null) {
    this.metadata=IClass.getClassMetadata(this,this.modifiers);
  }
  this.metadata.resolve(null,Package.rootPackage);
}
Program: 83716
Project: 83716
Buggy source:
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'T':
{
String s=desc.substring(start + 1,end - 1);
return new Type(s,Name.getQualified(s));
}
case 'L':
return readReferenceType(desc,start + 1,end - 1);
}
return null;
}

Fixed version (ground truth):
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'T':
{
String s=desc.substring(start + 1,end);
return new Type(s,Name.getQualified(s));
}
case 'L':
return readReferenceType(desc,start + 1,end);
}
return null;
}
Program: 83719
Project: 83719
Buggy source:
@Override public IMethod getFunctionalMethod(){
  IMethod m;
  if (this.body != null) {
    m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  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(){
  IMethod m;
  if (this.body != null) {
    m=this.body.getFunctionalMethod();
    if (m != null) {
      return m;
    }
  }
  return null;
}
Program: 83720
Project: 83720
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(markers,this.type,null,Name.apply,this.argument);
  if (match == null) {
    IValue value=this.argument.getFirstValue();
    markers.add(value.getPosition(),"String_Node_Str",value.getType().toString(),this.type.toString());
  }
 else {
    this.method=match;
  }
  this.argument.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(markers,this.type,null,Name.apply,this.argument);
  if (match == null) {
    IValue value=this.argument.getFirstValue();
    markers.add(value.getPosition(),"String_Node_Str",value.getType().toString(),this.type.toString());
  }
 else {
    this.method=match;
  }
  match.checkArguments(markers,null,this.argument,null);
  this.argument.checkTypes(markers,context);
}
Program: 83721
Project: 83721
Buggy source:
@Override public void addType(IType type){
  int index=this.upperBoundCount++;
  if (index >= this.upperBounds.length) {
    IType[] temp=new IType[this.upperBoundCount];
    System.arraycopy(this.upperBounds,0,temp,0,this.upperBounds.length);
    this.upperBounds=temp;
  }
  this.upperBounds[index]=type;
}

Fixed version (ground truth):
@Override public void addType(IType type){
  int index=this.upperBoundCount++;
  if (index >= this.upperBounds.length) {
    IType[] temp=new IType[this.upperBoundCount];
    System.arraycopy(this.upperBounds,0,temp,0,index);
    this.upperBounds=temp;
  }
  this.upperBounds[index]=type;
}
Program: 83722
Project: 83722
Buggy source:
@Override public void addUpperBound(IType bound){
  int index=this.upperBoundCount++;
  if (index >= this.upperBounds.length) {
    IType[] temp=new IType[this.upperBoundCount];
    System.arraycopy(this.upperBounds,0,temp,0,this.upperBounds.length);
    this.upperBounds=temp;
  }
  this.upperBounds[index]=bound;
}

Fixed version (ground truth):
@Override public void addUpperBound(IType bound){
  int index=this.upperBoundCount++;
  if (index >= this.upperBounds.length) {
    IType[] temp=new IType[this.upperBoundCount];
    System.arraycopy(this.upperBounds,0,temp,0,index);
    this.upperBounds=temp;
  }
  this.upperBounds[index]=bound;
}
Program: 83723
Project: 83723
Buggy source:
@Override public IType getSuperType(){
  return null;
}

Fixed version (ground truth):
@Override public IType getSuperType(){
  return this.arrayDimensions > 0 ? Types.OBJECT : null;
}
Program: 83724
Project: 83724
Buggy source:
@Override public IType getConcreteType(ITypeContext context){
  IType t=context.resolveType(this.typeVar);
  if (t != null) {
    if (this.arrayDimensions > 0) {
      return t.getArrayType(this.arrayDimensions);
    }
    if (t.isPrimitive()) {
      return t.getReferenceType();
    }
    return t;
  }
  return this;
}

Fixed version (ground truth):
@Override public IType getConcreteType(ITypeContext context){
  if (context == null) {
    return this;
  }
  IType t=context.resolveType(this.typeVar);
  if (t != null) {
    if (this.arrayDimensions > 0) {
      return t.getArrayType(this.arrayDimensions);
    }
    if (t.isPrimitive()) {
      return t.getReferenceType();
    }
    return t;
  }
  return this;
}
Program: 83725
Project: 83725
Buggy source:
public TypeVariableType(ITypeVariable typeVar){
  this.typeVar=typeVar;
}

Fixed version (ground truth):
public TypeVariableType(ITypeVariable typeVar,int arrayDimensions){
  this.typeVar=typeVar;
  this.arrayDimensions=arrayDimensions;
}
Program: 83726
Project: 83726
Buggy source:
@Override public int getArrayDimensions(){
  return 0;
}

Fixed version (ground truth):
@Override public int getArrayDimensions(){
  return this.arrayDimensions;
}
Program: 83727
Project: 83727
Buggy source:
@Override public void setArrayDimensions(int dimensions){
}

Fixed version (ground truth):
@Override public void setArrayDimensions(int dimensions){
  this.arrayDimensions=dimensions;
}
Program: 83728
Project: 83728
Buggy source:
@Override public boolean isArrayType(){
  return false;
}

Fixed version (ground truth):
@Override public boolean isArrayType(){
  return this.arrayDimensions > 0;
}
Program: 83729
Project: 83729
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(this.typeVar.getName());
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  for (int i=0; i < this.arrayDimensions; i++) {
    buffer.append('[');
  }
  buffer.append(this.typeVar.getName());
  for (int i=0; i < this.arrayDimensions; i++) {
    buffer.append(']');
  }
}
Program: 83730
Project: 83730
Buggy source:
public default int getArrayStoreOpcode(){
  return Opcodes.ASTORE;
}

Fixed version (ground truth):
public default int getArrayStoreOpcode(){
  return Opcodes.AASTORE;
}
Program: 83731
Project: 83731
Buggy source:
@Override public IType resolve(MarkerList markers,IContext context){
  if (this.theClass != null) {
    return this;
  }
  IClass iclass;
  IType t=resolvePrimitive(this.name);
  if (t != null) {
    if (this.arrayDimensions == 0) {
      return t;
    }
    return t.getArrayType(this.arrayDimensions);
  }
 else   if (this.internalName != null) {
    iclass=Package.rootPackage.resolveInternalClass(this.internalName);
  }
 else {
    ITypeVariable typeVar=context.resolveTypeVariable(this.name);
    if (typeVar != null) {
      return new TypeVariableType(typeVar);
    }
    iclass=context.resolveClass(this.name);
  }
  if (iclass != null) {
    this.theClass=iclass;
    this.internalName=iclass.getInternalName();
    return this;
  }
  if (markers != null) {
    markers.add(this.position,"String_Node_Str",this.toString());
  }
  return this;
}

Fixed version (ground truth):
@Override public IType resolve(MarkerList markers,IContext context){
  if (this.theClass != null) {
    return this;
  }
  IClass iclass;
  IType t=resolvePrimitive(this.name);
  if (t != null) {
    if (this.arrayDimensions == 0) {
      return t;
    }
    return t.getArrayType(this.arrayDimensions);
  }
 else   if (this.internalName != null) {
    iclass=Package.rootPackage.resolveInternalClass(this.internalName);
  }
 else {
    ITypeVariable typeVar=context.resolveTypeVariable(this.name);
    if (typeVar != null) {
      return new TypeVariableType(typeVar,this.arrayDimensions);
    }
    iclass=context.resolveClass(this.name);
  }
  if (iclass != null) {
    this.theClass=iclass;
    this.internalName=iclass.getInternalName();
    return this;
  }
  if (markers != null) {
    markers.add(this.position,"String_Node_Str",this.toString());
  }
  return this;
}
Program: 83732
Project: 83732
Buggy source:
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'L':
return readReferenceType(desc,start + 1,end - 1);
}
return null;
}

Fixed version (ground truth):
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'T':
{
String s=desc.substring(start + 1,end - 1);
return new Type(s,Name.getQualified(s));
}
case 'L':
return readReferenceType(desc,start + 1,end - 1);
}
return null;
}
Program: 83733
Project: 83733
Buggy source:
@Override public IType resolve(MarkerList markers,IContext context){
  if (this.theClass != null) {
    return this;
  }
  IClass iclass;
  IType t=resolvePrimitive(this.name);
  if (t != null) {
    if (this.arrayDimensions == 0) {
      return t;
    }
    return t.getArrayType(this.arrayDimensions);
  }
 else   if (this.internalName != null) {
    iclass=Package.rootPackage.resolveInternalClass(this.internalName);
  }
 else {
    ITypeVariable typeVar=context.resolveTypeVariable(this.name);
    if (typeVar != null) {
      return new TypeVariableType(typeVar,this.arrayDimensions);
    }
    iclass=context.resolveClass(this.name);
  }
  if (iclass != null) {
    this.theClass=iclass;
    this.internalName=iclass.getInternalName();
    return this;
  }
  if (markers != null) {
    markers.add(this.position,"String_Node_Str",this.toString());
  }
  return this;
}

Fixed version (ground truth):
@Override public IType resolve(MarkerList markers,IContext context){
  if (this.theClass != null) {
    return this;
  }
  IClass iclass;
  IType t=resolvePrimitive(this.name);
  if (t != null) {
    if (this.arrayDimensions == 0) {
      return t;
    }
    return t.getArrayType(this.arrayDimensions);
  }
  if (this.internalName != null) {
    iclass=Package.rootPackage.resolveInternalClass(this.internalName);
  }
 else {
    ITypeVariable typeVar=context.resolveTypeVariable(this.name);
    if (typeVar != null) {
      return new TypeVariableType(typeVar,this.arrayDimensions);
    }
    iclass=context.resolveClass(this.name);
  }
  if (iclass != null) {
    this.theClass=iclass;
    this.internalName=iclass.getInternalName();
    return this;
  }
  if (markers != null) {
    markers.add(this.position,"String_Node_Str",this.toString());
  }
  return this;
}
Program: 83734
Project: 83734
Buggy source:
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'T':
{
String s=desc.substring(start + 1,end);
return new Type(s,Name.getQualified(s));
}
case 'L':
return readReferenceType(desc,start + 1,end);
}
return null;
}

Fixed version (ground truth):
private static IType readType(String desc,int start,int end){
  int array=0;
  while (desc.charAt(start) == '[') {
    array++;
    start++;
  }
switch (desc.charAt(start)) {
case 'V':
    return Types.VOID.getArrayType(array);
case 'Z':
  return Types.BOOLEAN.getArrayType(array);
case 'B':
return Types.BYTE.getArrayType(array);
case 'S':
return Types.SHORT.getArrayType(array);
case 'C':
return Types.CHAR.getArrayType(array);
case 'I':
return Types.INT.getArrayType(array);
case 'J':
return Types.LONG.getArrayType(array);
case 'F':
return Types.FLOAT.getArrayType(array);
case 'D':
return Types.DOUBLE.getArrayType(array);
case 'T':
{
String s=desc.substring(start + 1,end);
return new Type(Name.getQualified(s));
}
case 'L':
return readReferenceType(desc,start + 1,end);
}
return null;
}
Program: 83735
Project: 83735
Buggy source:
@Override public ImmutableMap<K,V> $plus$plus(Map<? extends K,? extends V> map){
  return ((ImmutableMap<K,V>)map.immutable()).$plus(this.key,this.value);
}

Fixed version (ground truth):
@Override public ImmutableMap<K,V> $plus$plus(Map<? extends K,? extends V> map){
  int index=1;
  Tuple2<? extends K,? extends V>[] tuples=new Tuple2[1 + map.size()];
  tuples[0]=new Tuple2(this.key,this.value);
  for (  Tuple2<? extends K,? extends V> entry : map) {
    tuples[index++]=entry;
  }
  return new TupleMap(tuples,index);
}
Program: 83736
Project: 83736
Buggy source:
public HeaderComponent(ICodePosition position,boolean isStatic){
  this.position=position;
}

Fixed version (ground truth):
public HeaderComponent(ICodePosition position,boolean isStatic){
  this.position=position;
  this.isStatic=isStatic;
}
Program: 83737
Project: 83737
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    this.theClass=(CodeClass)context;
    return;
  }
  this.thePackage=(Package)context;
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    this.theClass=(CodeClass)context;
    return;
  }
  if (!(context instanceof Package)) {
    markers.add(this.position,"String_Node_Str");
    return;
  }
  this.thePackage=(Package)context;
}
Program: 83738
Project: 83738
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  this.write(writer,false);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label tryStart=new org.objectweb.asm.Label();
  org.objectweb.asm.Label tryEnd=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=new org.objectweb.asm.Label();
  writer.writeLabel(tryStart);
  if (this.action != null) {
    this.action.writeStatement(writer);
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
  }
  writer.writeLabel(tryEnd);
  for (int i=0; i < this.catchBlockCount; i++) {
    CatchBlock block=this.catchBlocks[i];
    org.objectweb.asm.Label handlerLabel=new org.objectweb.asm.Label();
    if (block.variable != null) {
      int localCount=writer.registerLocal();
      writer.writeLabel(handlerLabel);
      writer.writeVarInsn(Opcodes.ASTORE,localCount);
      block.variable.index=localCount;
      block.action.writeStatement(writer);
      writer.resetLocals(localCount);
    }
 else {
      writer.writeLabel(handlerLabel);
      writer.writeInsn(Opcodes.POP);
      block.action.writeStatement(writer);
    }
    writer.writeTryCatchBlock(tryStart,tryEnd,handlerLabel,block.type.getInternalName());
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
  }
  if (this.finallyBlock != null) {
    org.objectweb.asm.Label finallyLabel=new org.objectweb.asm.Label();
    writer.writeLabel(finallyLabel);
    writer.writeInsn(Opcodes.POP);
    writer.writeLabel(endLabel);
    this.finallyBlock.writeStatement(writer);
    writer.writeFinallyBlock(tryStart,tryEnd,finallyLabel);
  }
 else {
    writer.writeLabel(endLabel);
  }
}
Program: 83739
Project: 83739
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  if (this.finallyBlock == null) {
    IType type1=this.action.getType();
    for (int i=0; i < this.catchBlockCount; i++) {
      writer.getClassWriter().addCommonType(type1,this.catchBlocks[i].action.getType(),this.commonType);
    }
  }
  this.write(writer,true);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  this.commonType.writeDefaultValue(writer);
}
Program: 83740
Project: 83740
Buggy source:
private static void findUnits(File source,File output,Package pack){
  if (source.isDirectory()) {
    String name=source.getName();
    for (    String s : source.list()) {
      findUnits(new CodeFile(source,s),new File(output,s),pack == null ? Package.rootPackage : pack.createSubPackage(name));
    }
    return;
  }
  String fileName=source.getPath();
  if (!config.compileFile(fileName)) {
    return;
  }
  if (fileName.endsWith("String_Node_Str") || fileName.endsWith("String_Node_Str")) {
    return;
  }
  files.add(output);
  if (fileName.endsWith("String_Node_Str")) {
    DWTFile dwt=new DWTFile(pack,(CodeFile)source,output);
    units.add(dwt);
    return;
  }
  if (fileName.endsWith("String_Node_Str")) {
    DyvilUnit unit=new DyvilUnit(pack,(CodeFile)source,output);
    pack.addCompilationUnit(unit);
    units.add(unit);
    return;
  }
  if (fileName.endsWith("String_Node_Str")) {
    DyvilHeader header=new DyvilHeader(pack,(CodeFile)source,output);
    pack.addCompilationUnit(header);
    units.add(0,header);
    return;
  }
}

Fixed version (ground truth):
private static void findUnits(File source,File output,Package pack){
  if (source.isDirectory()) {
    String name=source.getName();
    for (    String s : source.list()) {
      findUnits(new CodeFile(source,s),new File(output,s),pack == null ? Package.rootPackage : pack.createSubPackage(name));
    }
    return;
  }
  String fileName=source.getPath();
  if (!config.compileFile(fileName)) {
    return;
  }
  if (fileName.endsWith("String_Node_Str") || fileName.endsWith("String_Node_Str")) {
    return;
  }
  files.add(output);
  if (fileName.endsWith("String_Node_Str")) {
    DWTFile dwt=new DWTFile(pack,(CodeFile)source,output);
    units.add(dwt);
    return;
  }
  if (fileName.endsWith("String_Node_Str") || fileName.endsWith("String_Node_Str")) {
    DyvilUnit unit=new DyvilUnit(pack,(CodeFile)source,output);
    pack.addCompilationUnit(unit);
    units.add(unit);
    return;
  }
  if (fileName.endsWith("String_Node_Str")) {
    DyvilHeader header=new DyvilHeader(pack,(CodeFile)source,output);
    pack.addCompilationUnit(header);
    units.add(0,header);
    return;
  }
}
Program: 83741
Project: 83741
Buggy source:
@Override public void addResolveError(MarkerList markers){
  Marker marker;
  if (this.arguments.isEmpty()) {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
 else {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
  marker.addInfo("String_Node_Str" + this.name.qualified);
  if (this.instance != null) {
    marker.addInfo("String_Node_Str" + this.instance.getType());
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  Util.typesToString("String_Node_Str",this.arguments,"String_Node_Str",builder);
  marker.addInfo(builder.append('}').toString());
}

Fixed version (ground truth):
@Override public void addResolveError(MarkerList markers){
  Marker marker;
  if (this.arguments.isEmpty()) {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
 else {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
  marker.addInfo("String_Node_Str" + this.name.qualified);
  if (this.instance != null) {
    marker.addInfo("String_Node_Str" + this.instance.getType());
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  Util.typesToString("String_Node_Str",this.arguments,"String_Node_Str",builder);
  marker.addInfo(builder.toString());
}
Program: 83742
Project: 83742
Buggy source:
@Override public boolean addRawAnnotation(String type){
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.SEALED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.DEPRECATED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.FUNCTIONAL;
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.SEALED;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.FUNCTIONAL;
return false;
}
return true;
}
Program: 83743
Project: 83743
Buggy source:
@Override public boolean addRawAnnotation(String type){
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.LAZY;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.SEALED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.DEPRECATED;
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.LAZY;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.TRANSIENT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.VOLATILE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
}
return true;
}
Program: 83744
Project: 83744
Buggy source:
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.NATIVE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}
Program: 83747
Project: 83747
Buggy source:
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}
Program: 83748
Project: 83748
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}
Program: 83749
Project: 83749
Buggy source:
@Override public void writeCall(MethodWriter writer,IValue instance,IArguments arguments,IType type){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeIntrinsic(writer,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  if (type == Types.VOID) {
    if (this.type != Types.VOID) {
      writer.writeInsn(Opcodes.POP);
    }
    return;
  }
  if (type != null) {
    if (type != this.type && !type.isSuperTypeOf(this.type)) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
  }
}

Fixed version (ground truth):
@Override public void writeCall(MethodWriter writer,IValue instance,IArguments arguments,IType type){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  if (type == Types.VOID) {
    if (this.type != Types.VOID) {
      writer.writeInsn(Opcodes.POP);
    }
    return;
  }
  if (type != null) {
    if (type != this.type && !type.isSuperTypeOf(this.type)) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
  }
}
Program: 83751
Project: 83751
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
switch (type) {
case Tokens.STRING_START:
case Tokens.STRING_PART:
    this.value.addString(token.stringValue());
  pm.pushParser(new ExpressionParser(this));
return;
case Tokens.STRING_END:
this.value.addString(token.stringValue());
pm.popParser();
return;
}
throw new SyntaxError(token,"String_Node_Str");
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
switch (type) {
case Tokens.STRING_START:
case Tokens.STRING_PART:
{
      int nextType=token.next().type();
      if (nextType == Tokens.STRING_PART || nextType == Tokens.STRING_END) {
        throw new SyntaxError(token.next(),"String_Node_Str");
      }
      this.value.addString(token.stringValue());
      pm.pushParser(new ExpressionParser(this));
      return;
    }
case Tokens.STRING_END:
  this.value.addString(token.stringValue());
pm.popParser();
return;
}
throw new SyntaxError(token,"String_Node_Str");
}
Program: 83752
Project: 83752
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.forStart);
  if (this.type != 0) {
    this.variable.type.toString(prefix,buffer);
    buffer.append(' ').append(this.variable.name).append(Formatting.Statements.forEachSeperator);
    this.variable.value.toString(prefix,buffer);
  }
 else {
    if (this.variable != null) {
      this.variable.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.condition != null) {
      buffer.append(' ');
      this.condition.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.update != null) {
      buffer.append(' ');
      this.update.toString(prefix,buffer);
    }
  }
  buffer.append(Formatting.Statements.forEnd);
  if (this.then != null) {
    if (this.then.isStatement()) {
      buffer.append('\n').append(prefix);
      this.then.toString(prefix,buffer);
    }
 else {
      buffer.append(' ');
      this.then.toString(prefix,buffer);
    }
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.forStart);
  if (this.type != 0) {
    this.variable.type.toString(prefix,buffer);
    buffer.append(' ').append(this.variable.name).append(Formatting.Statements.forEachSeperator);
    this.variable.value.toString(prefix,buffer);
  }
 else {
    if (this.variable != null) {
      this.variable.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.condition != null) {
      buffer.append(' ');
      this.condition.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.update != null) {
      buffer.append(' ');
      this.update.toString(prefix,buffer);
    }
  }
  buffer.append(Formatting.Statements.forEnd);
  if (this.then != null) {
    this.then.toString(prefix,buffer);
  }
}
Program: 83753
Project: 83753
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.valueCount == 0) {
    buffer.append(Formatting.Expression.emptyExpression);
  }
 else {
    buffer.append('\n').append(prefix).append('{').append('\n');
    String prefix1=prefix + Formatting.Method.indent;
    IValue prev=null;
    for (int i=0; i < this.valueCount; i++) {
      IValue value=this.values[i];
      buffer.append(prefix1);
      if (prev != null) {
        ICodePosition pos=value.getPosition();
        if (pos != null && pos.endLine() - prev.getPosition().startLine() > 0) {
          buffer.append('\n').append(prefix1);
        }
      }
      if (this.labels != null) {
        Label l=this.labels[i];
        if (l != null) {
          buffer.append(l.name).append(Formatting.Expression.labelSeperator);
        }
      }
      value.toString(prefix1,buffer);
      buffer.append("String_Node_Str");
      prev=value;
    }
    buffer.append(prefix).append('}');
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.valueCount == 0) {
    buffer.append(Formatting.Expression.emptyExpression);
  }
 else {
    buffer.append('\n').append(prefix).append('{').append('\n');
    String prefix1=prefix + Formatting.Method.indent;
    IValue prev=null;
    for (int i=0; i < this.valueCount; i++) {
      IValue value=this.values[i];
      buffer.append(prefix1);
      if (prev != null) {
        ICodePosition pos=value.getPosition();
        if (pos != null && pos.endLine() - prev.getPosition().startLine() > 1) {
          buffer.append('\n').append(prefix1);
        }
      }
      if (this.labels != null) {
        Label l=this.labels[i];
        if (l != null) {
          buffer.append(l.name).append(Formatting.Expression.labelSeperator);
        }
      }
      value.toString(prefix1,buffer);
      buffer.append("String_Node_Str");
      prev=value;
    }
    buffer.append(prefix).append('}');
  }
}
Program: 83754
Project: 83754
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.lock.resolveTypes(markers,context);
  this.block.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.lock.resolveTypes(markers,context);
  if (this.block.isStatement()) {
    ((IStatement)this.block).setParent(this);
  }
  this.block.resolveTypes(markers,context);
}
Program: 83755
Project: 83755
Buggy source:
private void write(MethodWriter writer,boolean expression){
  int localCount=writer.registerLocal();
  this.lock.writeExpression(writer);
  writer.writeInsn(Opcodes.DUP);
  writer.writeVarInsn(Opcodes.ASTORE,localCount);
  writer.writeInsn(Opcodes.MONITORENTER);
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerStart=new org.objectweb.asm.Label();
  org.objectweb.asm.Label throwLabel=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerEnd=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  if (expression) {
    this.block.writeExpression(writer);
  }
 else {
    this.block.writeStatement(writer);
  }
  writer.writeVarInsn(Opcodes.ALOAD,localCount);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(end);
  writer.writeJumpInsn(Opcodes.GOTO,handlerEnd);
  writer.writeLabel(handlerStart);
  writer.writeVarInsn(Opcodes.ALOAD,localCount);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(throwLabel);
  writer.writeInsn(Opcodes.ATHROW);
  if (expression) {
    this.block.getType().writeDefaultValue(writer);
  }
  writer.resetLocals(localCount);
  writer.writeLabel(handlerEnd);
  writer.writeFinallyBlock(start,end,handlerStart);
  writer.writeFinallyBlock(handlerStart,throwLabel,handlerStart);
}

Fixed version (ground truth):
private void write(MethodWriter writer,boolean expression){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerStart=new org.objectweb.asm.Label();
  org.objectweb.asm.Label throwLabel=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerEnd=new org.objectweb.asm.Label();
  this.lock.writeExpression(writer);
  writer.writeInsn(Opcodes.DUP);
  int varIndex=writer.startSync();
  writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  writer.writeInsn(Opcodes.MONITORENTER);
  writer.writeLabel(start);
  if (expression) {
    this.block.writeExpression(writer);
  }
 else {
    this.block.writeStatement(writer);
  }
  writer.endSync();
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(end);
  writer.writeJumpInsn(Opcodes.GOTO,handlerEnd);
  writer.writeLabel(handlerStart);
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(throwLabel);
  writer.writeInsn(Opcodes.ATHROW);
  if (expression) {
    this.block.getType().writeDefaultValue(writer);
  }
  writer.resetLocals(varIndex);
  writer.writeLabel(handlerEnd);
  writer.writeFinallyBlock(start,end,handlerStart);
  writer.writeFinallyBlock(handlerStart,throwLabel,handlerStart);
}
Program: 83756
Project: 83756
Buggy source:
@Override public void tokenize(){
  this.tokens=Dlex.tokenIterator(this.inputFile.getCode());
}

Fixed version (ground truth):
@Override public void tokenize(){
  this.tokens=Dlex.tokenIterator(this.inputFile.getCode());
  this.tokens.inferSemicolons();
}
Program: 83757
Project: 83757
Buggy source:
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilHeaderParser(this));
  manager.semicolonInference=true;
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}

Fixed version (ground truth):
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilHeaderParser(this));
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}
Program: 83758
Project: 83758
Buggy source:
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilUnitParser(this));
  manager.semicolonInference=true;
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}

Fixed version (ground truth):
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilUnitParser(this));
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}