nus-yam/ex-repair huggingface dataset:
Program: 83296
Project: 83296
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,context);
  }
  super.resolveTypes(markers,this);
  for (int i=0; i < this.annotationCount; i++) {
    Annotation annotation=this.annotations[i];
    if (annotation.type.getTheClass() != Types.INTRINSIC_CLASS) {
      continue;
    }
    try {
      Array array=(Array)annotation.arguments.getValue(0,Annotation.VALUE);
      int len=array.valueCount();
      int[] opcodes=new int[len];
      for (int j=0; j < len; j++) {
        IntValue v=(IntValue)array.getValue(j);
        opcodes[j]=v.value;
      }
      this.intrinsicOpcodes=opcodes;
    }
 catch (    NullPointerException|ClassCastException ex) {
    }
    break;
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolve(markers,this,TypePosition.TYPE);
  }
  int index=(this.modifiers & Modifiers.STATIC) == 0 ? 1 : 0;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,this);
    param.setIndex(index);
    IType type=param.getType();
    if (type == Types.LONG || type == Types.DOUBLE) {
      index+=2;
    }
 else {
      index++;
    }
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
 else   if (this.theClass.hasModifier(Modifiers.ABSTRACT)) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,context);
  }
  super.resolveTypes(markers,this);
  for (int i=0; i < this.annotationCount; i++) {
    Annotation annotation=this.annotations[i];
    if (annotation.type.getTheClass() != Types.INTRINSIC_CLASS) {
      continue;
    }
    try {
      Array array=(Array)annotation.arguments.getValue(0,Annotation.VALUE);
      int len=array.valueCount();
      int[] opcodes=new int[len];
      for (int j=0; j < len; j++) {
        IntValue v=(IntValue)array.getValue(j);
        opcodes[j]=v.value;
      }
      this.intrinsicOpcodes=opcodes;
    }
 catch (    NullPointerException|ClassCastException ex) {
    }
    break;
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolve(markers,this,TypePosition.TYPE);
  }
  int index=(this.modifiers & Modifiers.STATIC) == 0 ? 1 : 0;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,this);
    param.setIndex(index);
    IType type=param.getType();
    if (type == Types.LONG || type == Types.DOUBLE) {
      index+=2;
    }
 else {
      index++;
    }
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS)) {
    this.modifiers|=Modifiers.ABSTRACT | Modifiers.PUBLIC;
  }
 else   if (this.theClass.hasModifier(Modifiers.ABSTRACT)) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
}
Program: 83299
Project: 83299
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar){
  return this.map.get(typeVar);
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar){
  IType type=this.map.get(typeVar);
  if (type == null) {
    return Types.ANY;
  }
  return type;
}
Program: 83301
Project: 83301
Buggy source:
@Override public void write(ClassWriter writer) throws BytecodeException {
  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.name,this.getLambdaDescriptor(),null,null));
  if (instance) {
    mw.setThisType(this.thisClass.getInternalName());
  }
  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.getReferenceType(),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);
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer) throws BytecodeException {
  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.name,this.getLambdaDescriptor(),null,null));
  int index=0;
  if (instance) {
    mw.setThisType(this.thisClass.getInternalName());
    index=1;
  }
  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.getReferenceType(),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: 83302
Project: 83302
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,context);
  }
  this.context=context;
  this.value.resolveTypes(markers,this);
  this.context=null;
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,context);
    IType type=param.getType();
    if (type != null && type.isPrimitive()) {
      param.setType(type.getReferenceType());
    }
  }
  this.context=context;
  this.value.resolveTypes(markers,this);
  this.context=null;
}
Program: 83303
Project: 83303
Buggy source:
public default IType getReferenceType(){
  return null;
}

Fixed version (ground truth):
public default IType getReferenceType(){
  return this.getType();
}
Program: 83304
Project: 83304
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar){
  int index=typeVar.getIndex();
  if (this.method.getTypeVariable(index) == typeVar) {
    if (index > this.genericCount) {
      return new TypeVarType(typeVar);
    }
    return this.generics[index];
  }
  return this.instanceType.resolveType(typeVar);
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar){
  int index=typeVar.getIndex();
  if (this.isMethodTypeVariable(typeVar)) {
    if (index > this.genericCount) {
      return new TypeVarType(typeVar);
    }
    return this.generics[index];
  }
  return this.instanceType.resolveType(typeVar);
}
Program: 83305
Project: 83305
Buggy source:
@Override public void addMapping(ITypeVariable typeVar,IType type){
  if (type == Types.UNKNOWN) {
    return;
  }
  int index=typeVar.getIndex();
  if (this.method.getTypeVariable(index) != typeVar) {
    return;
  }
  if (index < this.genericCount) {
    this.generics[index]=this.generics[index].combine(type);
    return;
  }
  this.genericCount=index + 1;
  if (index >= this.generics.length) {
    IType[] temp=new IType[index + 1];
    System.arraycopy(this.generics,0,temp,0,this.generics.length);
    this.generics=temp;
  }
  this.generics[typeVar.getIndex()]=type;
}

Fixed version (ground truth):
@Override public void addMapping(ITypeVariable typeVar,IType type){
  if (type == Types.UNKNOWN) {
    return;
  }
  int index=typeVar.getIndex();
  if (!this.isMethodTypeVariable(typeVar)) {
    return;
  }
  if (index < this.genericCount) {
    this.generics[index]=this.generics[index].combine(type);
    return;
  }
  this.genericCount=index + 1;
  if (index >= this.generics.length) {
    IType[] temp=new IType[index + 1];
    System.arraycopy(this.generics,0,temp,0,this.generics.length);
    this.generics=temp;
  }
  this.generics[typeVar.getIndex()]=type;
}
Program: 83306
Project: 83306
Buggy source:
public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.typeCount(); i++) {
    this.generics[i]=this.generics[i].resolve(markers,context,TypePosition.TYPE);
  }
}

Fixed version (ground truth):
public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i]=this.generics[i].resolve(markers,context,TypePosition.TYPE);
  }
}
Program: 83307
Project: 83307
Buggy source:
@Override public IType getConcreteType(ITypeContext context){
  if (context == null) {
    return this;
  }
  IType t=context.resolveType(this.typeVar);
  if (t != null) {
    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 != Types.ANY) {
    if (t.isPrimitive()) {
      return t.getReferenceType();
    }
    return t;
  }
  return this;
}
Program: 83308
Project: 83308
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].resolve(markers,context);
  }
  if (this.value != null) {
    this.value=this.value.resolve(markers,this);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.value.withType(this.type,null,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      if (inferType) {
        this.type=value1.getType();
      }
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
    this.type=Types.ANY;
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].resolve(markers,context);
  }
  if (this.value != null) {
    this.value=this.value.resolve(markers,this);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.value.withType(this.type,this.type,markers,this);
    if (value1 == null) {
      Marker marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
      if (inferType) {
        this.type=value1.getType();
      }
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
    this.type=Types.ANY;
  }
}
Program: 83309
Project: 83309
Buggy source:
@Override public GenericData getGenericData(GenericData genericData,IValue instance,IArguments arguments){
  if (!this.hasTypeVariables()) {
    return genericData;
  }
  if (genericData == null) {
    genericData=new GenericData(this,this.genericCount);
    if (instance != null) {
      genericData.instanceType=instance.getType();
    }
    this.inferTypes(genericData,instance,arguments);
    return genericData;
  }
  genericData.method=this;
  if (instance != null) {
    genericData.instanceType=instance.getType();
  }
  genericData.setTypeCount(this.genericCount);
  this.inferTypes(genericData,instance,arguments);
  return genericData;
}

Fixed version (ground truth):
@Override public GenericData getGenericData(GenericData genericData,IValue instance,IArguments arguments){
  if (!this.hasTypeVariables()) {
    return genericData;
  }
  if (genericData == null) {
    genericData=new GenericData(this,this.genericCount);
    this.inferTypes(genericData,instance,arguments);
    return genericData;
  }
  genericData.method=this;
  genericData.setTypeCount(this.genericCount);
  this.inferTypes(genericData,instance,arguments);
  return genericData;
}
Program: 83310
Project: 83310
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,context);
  }
  super.resolveTypes(markers,this);
  for (int i=0; i < this.annotationCount; i++) {
    Annotation annotation=this.annotations[i];
    if (annotation.type.getTheClass() != Types.INTRINSIC_CLASS) {
      continue;
    }
    try {
      Array array=(Array)annotation.arguments.getValue(0,Annotation.VALUE);
      int len=array.valueCount();
      int[] opcodes=new int[len];
      for (int j=0; j < len; j++) {
        IntValue v=(IntValue)array.getValue(j);
        opcodes[j]=v.value;
      }
      this.intrinsicOpcodes=opcodes;
    }
 catch (    NullPointerException|ClassCastException ex) {
    }
    break;
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolve(markers,this,TypePosition.TYPE);
  }
  int index=(this.modifiers & Modifiers.STATIC) == 0 ? 1 : 0;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,this);
    param.setIndex(index);
    IType type=param.getType();
    if (type == Types.LONG || type == Types.DOUBLE) {
      index+=2;
    }
 else {
      index++;
    }
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,context);
  }
  super.resolveTypes(markers,this);
  for (int i=0; i < this.annotationCount; i++) {
    Annotation annotation=this.annotations[i];
    if (annotation.type.getTheClass() != Types.INTRINSIC_CLASS) {
      continue;
    }
    try {
      Array array=(Array)annotation.arguments.getValue(0,Annotation.VALUE);
      int len=array.valueCount();
      int[] opcodes=new int[len];
      for (int j=0; j < len; j++) {
        IntValue v=(IntValue)array.getValue(j);
        opcodes[j]=v.value;
      }
      this.intrinsicOpcodes=opcodes;
    }
 catch (    NullPointerException|ClassCastException ex) {
    }
    break;
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolve(markers,this,TypePosition.TYPE);
  }
  int index=(this.modifiers & Modifiers.STATIC) == 0 ? 1 : 0;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,this);
    param.setIndex(index);
    IType type=param.getType();
    if (type == Types.LONG || type == Types.DOUBLE) {
      index+=2;
    }
 else {
      index++;
    }
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
 else   if (this.theClass.hasModifier(Modifiers.ABSTRACT)) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
}
Program: 83311
Project: 83311
Buggy source:
private void inferTypes(GenericData genericData,IValue instance,IArguments arguments){
  int len=arguments.size();
  IParameter param;
  if (instance != null && (this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    this.parameters[0].getType().inferTypes(instance.getType(),genericData);
    for (int i=0; i < len; i++) {
      param=this.parameters[i + 1];
      param.getType().inferTypes(arguments.getType(i,param),genericData);
    }
  }
 else {
    len=Math.min(this.parameterCount,len);
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      param.getType().inferTypes(arguments.getType(i,param),genericData);
    }
  }
}

Fixed version (ground truth):
private void inferTypes(GenericData genericData,IValue instance,IArguments arguments){
  if (instance != null) {
    genericData.instanceType=instance.getType();
  }
 else {
    genericData.instanceType=this.theClass.getType();
  }
  int len=arguments.size();
  IParameter param;
  if (instance != null && (this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    this.parameters[0].getType().inferTypes(instance.getType(),genericData);
    for (int i=0; i < len; i++) {
      param=this.parameters[i + 1];
      param.getType().inferTypes(arguments.getType(i,param),genericData);
    }
  }
 else {
    len=Math.min(this.parameterCount,len);
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      param.getType().inferTypes(arguments.getType(i,param),genericData);
    }
  }
}
Program: 83312
Project: 83312
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    this.checkOverride(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    this.checkOverride(markers,context);
  }
}
Program: 83313
Project: 83313
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar){
  int index=typeVar.getIndex();
  if (index == this.parameterCount) {
    return this.returnType;
  }
  return this.parameterTypes[index];
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar){
  int index=typeVar.getIndex();
  if (index == this.parameterCount) {
    return this.returnType;
  }
  if (index > this.parameterCount) {
    return Types.ANY;
  }
  return this.parameterTypes[index];
}
Program: 83314
Project: 83314
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.parameterCount == 1) {
    this.parameterTypes[0].toString(prefix,buffer);
    buffer.append(' ');
  }
 else   if (this.parameterCount > 0) {
    buffer.append(Formatting.Method.parametersStart);
    Util.astToString(prefix,this.parameterTypes,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
    buffer.append(Formatting.Method.parametersEnd);
    buffer.append(' ');
  }
  buffer.append(Formatting.Expression.lambdaSeperator);
  this.returnType.toString("String_Node_Str",buffer);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.parameterCount == 1) {
    if (this.parameterTypes[0].typeTag() == TUPLE) {
      buffer.append(Formatting.Method.parametersStart);
      this.parameterTypes[0].toString(prefix,buffer);
      buffer.append(Formatting.Method.parametersEnd);
    }
 else {
      this.parameterTypes[0].toString(prefix,buffer);
    }
    buffer.append(' ');
  }
 else   if (this.parameterCount > 0) {
    buffer.append(Formatting.Method.parametersStart);
    Util.astToString(prefix,this.parameterTypes,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
    buffer.append(Formatting.Method.parametersEnd);
    buffer.append(' ');
  }
  buffer.append(Formatting.Expression.lambdaSeperator);
  this.returnType.toString("String_Node_Str",buffer);
}
Program: 83315
Project: 83315
Buggy source:
private void checkMethod(IMethod m){
  Name name=m.getName();
  if (name == Name.equals) {
    if (m.parameterCount() == 1 && m.getParameter(0).getType().equals(Types.OBJECT)) {
      this.methods|=EQUALS;
    }
    return;
  }
  if (name == Name.hashCode) {
    if (m.parameterCount() == 0) {
      this.methods|=HASHCODE;
    }
    return;
  }
  if (name == Name.toString) {
    if (m.parameterCount() == 0) {
      this.methods|=TOSTRING;
    }
    return;
  }
  if (name == Name.apply) {
    if (m.parameterCount() == this.theClass.parameterCount()) {
      int len=this.theClass.parameterCount();
      for (int i=0; i < len; i++) {
        IType t1=m.getParameter(i).getType();
        IType t2=m.getParameter(i).getType();
        if (!t1.classEquals(t2) || t1.getArrayDimensions() != t2.getArrayDimensions()) {
          return;
        }
      }
      this.methods|=APPLY;
    }
    return;
  }
}

Fixed version (ground truth):
private void checkMethod(IMethod m){
  Name name=m.getName();
  if (name == Name.equals) {
    if (m.parameterCount() == 1 && m.getParameter(0).getType().equals(Types.OBJECT)) {
      this.methods|=EQUALS;
    }
    return;
  }
  if (name == Name.hashCode) {
    if (m.parameterCount() == 0) {
      this.methods|=HASHCODE;
    }
    return;
  }
  if (name == Name.toString) {
    if (m.parameterCount() == 0) {
      this.methods|=TOSTRING;
    }
    return;
  }
  if (name == Name.apply) {
    if (m.parameterCount() == this.theClass.parameterCount()) {
      int len=this.theClass.parameterCount();
      for (int i=0; i < len; i++) {
        IType t1=m.getParameter(i).getType();
        IType t2=m.getParameter(i).getType();
        if (!t1.equals(t2)) {
          return;
        }
      }
      this.methods|=APPLY;
    }
    return;
  }
}
Program: 83316
Project: 83316
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  IClassBody body=this.theClass.getBody();
  if (body != null) {
    IConstructor c=body.getConstructor(this.theClass.getParameters(),this.theClass.parameterCount());
    if (c != null) {
      this.constructor=c;
      this.methods|=CONSTRUCTOR;
      return;
    }
  }
  Constructor constructor=new Constructor(this.theClass);
  constructor.type=this.theClass.getType();
  constructor.modifiers=Modifiers.PUBLIC;
  int parameterCount=this.theClass.parameterCount();
  IParameter[] parameters=this.theClass.getParameters();
  constructor.setParameters(parameters,parameterCount);
  if (parameterCount > 0 && parameters[parameterCount - 1].isVarargs()) {
    constructor.setVarargs();
  }
  this.constructor=constructor;
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  IClassBody body=this.theClass.getBody();
  if (body != null && body.constructorCount() > 0) {
    IConstructor c=body.getConstructor(this.theClass.getParameters(),this.theClass.parameterCount());
    if (c != null) {
      this.constructor=c;
      this.methods|=CONSTRUCTOR;
      return;
    }
    if (this.theClass.parameterCount() == 0) {
      this.methods|=CONSTRUCTOR;
      return;
    }
  }
  Constructor constructor=new Constructor(this.theClass);
  constructor.type=this.theClass.getType();
  constructor.modifiers=Modifiers.PUBLIC;
  int parameterCount=this.theClass.parameterCount();
  IParameter[] parameters=this.theClass.getParameters();
  constructor.setParameters(parameters,parameterCount);
  if (parameterCount > 0 && parameters[parameterCount - 1].isVarargs()) {
    constructor.setVarargs();
  }
  this.constructor=constructor;
}
Program: 83317
Project: 83317
Buggy source:
@Override public void addValue(int index,IValue value){
  int i=this.valueCount++;
  System.arraycopy(this.values,index,this.values,index + 1,i - index + 1);
  this.values[index]=value;
}

Fixed version (ground truth):
@Override public void addValue(int index,IValue value){
  IValue[] temp=new IValue[++this.valueCount];
  System.arraycopy(this.values,0,temp,0,index);
  temp[index]=value;
  System.arraycopy(this.values,index,temp,index + 1,this.valueCount - index - 1);
  this.values=temp;
}
Program: 83318
Project: 83318
Buggy source:
@Override public void addValue(int index,IValue value){
  int i=this.valueCount++;
  System.arraycopy(this.values,index,this.values,index + 1,i - index + 1);
  this.values[index]=value;
}

Fixed version (ground truth):
@Override public void addValue(int index,IValue value){
  IValue[] temp=new IValue[++this.valueCount];
  System.arraycopy(this.values,0,temp,0,index);
  temp[index]=value;
  System.arraycopy(this.values,index,temp,index + 1,this.valueCount - index - 1);
  this.values=temp;
}
Program: 83319
Project: 83319
Buggy source:
@Override public void addValue(int index,IValue value){
  int i=this.valueCount++;
  System.arraycopy(this.values,index,this.values,index + 1,i - index + 1);
  this.values[index]=value;
}

Fixed version (ground truth):
@Override public void addValue(int index,IValue value){
  IValue[] temp=new IValue[++this.valueCount];
  System.arraycopy(this.values,0,temp,0,index);
  temp[index]=value;
  System.arraycopy(this.values,index,temp,index + 1,this.valueCount - index - 1);
  this.values=temp;
}
Program: 83321
Project: 83321
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
  }
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    IClassBody body=((IClass)context).getBody();
    IDataMember field=body.getField(this.name);
    if (field != null) {
      this.field=field;
      return;
    }
    this.methods=new ArrayList();
    int len=body.methodCount();
    for (int i=0; i < len; i++) {
      IMethod m=body.getMethod(i);
      if (m.getName() == this.name) {
        this.methods.add(m);
      }
    }
    if (!this.methods.isEmpty()) {
      return;
    }
    markers.add(this.position,"String_Node_Str",this.name.qualified);
    return;
  }
  Package pack=context.resolvePackage(this.name);
  if (pack != null) {
    this.thePackage=pack;
    return;
  }
  IClass iclass=context.resolveClass(this.name);
  if (iclass != null) {
    this.theClass=iclass;
    return;
  }
  markers.add(this.position,"String_Node_Str",this.name.qualified);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
    if (context == null) {
      return;
    }
  }
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    IClassBody body=((IClass)context).getBody();
    IDataMember field=body.getField(this.name);
    if (field != null) {
      this.field=field;
      return;
    }
    this.methods=new ArrayList();
    int len=body.methodCount();
    for (int i=0; i < len; i++) {
      IMethod m=body.getMethod(i);
      if (m.getName() == this.name) {
        this.methods.add(m);
      }
    }
    if (!this.methods.isEmpty()) {
      return;
    }
    markers.add(this.position,"String_Node_Str",this.name.qualified);
    return;
  }
  Package pack=context.resolvePackage(this.name);
  if (pack != null) {
    this.thePackage=pack;
    return;
  }
  IClass iclass=context.resolveClass(this.name);
  if (iclass != null) {
    this.theClass=iclass;
    return;
  }
  markers.add(this.position,"String_Node_Str",this.name.qualified);
}
Program: 83322
Project: 83322
Buggy source:
@Override public IType resolveType(Name name){
  ITypeAlias typeAlias=this.typeAliases.get(name);
  if (typeAlias != null) {
    return typeAlias.getType();
  }
  IClass iclass=this.resolveClass(name);
  if (iclass != null) {
    return new ClassType(iclass);
  }
  for (int i=0; i < this.includeCount; i++) {
    IType t=this.includes[i].getHeader().resolveType(name);
    if (t != null) {
      return t;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IType resolveType(Name name){
  ITypeAlias typeAlias=this.typeAliases.get(name);
  if (typeAlias != null) {
    return typeAlias.getType();
  }
  IClass iclass=this.resolveClass(name);
  if (iclass != null) {
    return new ClassType(iclass);
  }
  for (int i=0; i < this.includeCount; i++) {
    IType t=this.includes[i].resolveType(name);
    if (t != null) {
      return t;
    }
  }
  return null;
}
Program: 83323
Project: 83323
Buggy source:
@Override public IClass resolveClass(Name name){
  IClass iclass;
  for (int i=0; i < this.importCount; i++) {
    iclass=this.imports[i].resolveClass(name);
    if (iclass != null) {
      return iclass;
    }
  }
  for (int i=0; i < this.includeCount; i++) {
    iclass=this.includes[i].getHeader().resolveClass(name);
    if (iclass != null) {
      return iclass;
    }
  }
  if (this.pack != null) {
    return this.pack.resolveClass(name);
  }
  return null;
}

Fixed version (ground truth):
@Override public IClass resolveClass(Name name){
  IClass iclass;
  for (int i=0; i < this.importCount; i++) {
    iclass=this.imports[i].resolveClass(name);
    if (iclass != null) {
      return iclass;
    }
  }
  for (int i=0; i < this.includeCount; i++) {
    iclass=this.includes[i].resolveClass(name);
    if (iclass != null) {
      return iclass;
    }
  }
  if (this.pack != null) {
    return this.pack.resolveClass(name);
  }
  return null;
}
Program: 83324
Project: 83324
Buggy source:
@Override public IDataMember resolveField(Name name){
  for (int i=0; i < this.usingCount; i++) {
    IDataMember field=this.usings[i].resolveField(name);
    if (field != null) {
      return field;
    }
  }
  for (int i=0; i < this.includeCount; i++) {
    IDataMember field=this.includes[i].getHeader().resolveField(name);
    if (field != null) {
      return field;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IDataMember resolveField(Name name){
  for (int i=0; i < this.usingCount; i++) {
    IDataMember field=this.usings[i].resolveField(name);
    if (field != null) {
      return field;
    }
  }
  for (int i=0; i < this.includeCount; i++) {
    IDataMember field=this.includes[i].resolveField(name);
    if (field != null) {
      return field;
    }
  }
  return null;
}
Program: 83325
Project: 83325
Buggy source:
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,Name name,IArguments arguments){
  for (int i=0; i < this.usingCount; i++) {
    this.usings[i].getMethodMatches(list,instance,name,arguments);
  }
  for (int i=0; i < this.includeCount; i++) {
    this.includes[i].getHeader().getMethodMatches(list,instance,name,arguments);
  }
}

Fixed version (ground truth):
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,Name name,IArguments arguments){
  for (int i=0; i < this.usingCount; i++) {
    this.usings[i].getMethodMatches(list,instance,name,arguments);
  }
  for (int i=0; i < this.includeCount; i++) {
    this.includes[i].getMethodMatches(list,instance,name,arguments);
  }
}
Program: 83326
Project: 83326
Buggy source:
public final void parse(MarkerList markers,TokenIterator tokens){
  this.tokens=tokens;
  IToken token=null;
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    SyntaxError ex) {
{
        if (ex.reparse) {
          this.reparse=true;
        }
        markers.add(ex);
      }
    }
catch (    Exception ex) {
{
        DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
        markers.add(new SyntaxError(token,"String_Node_Str" + token + "String_Node_Str"+ ex.getMessage()));
      }
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.name+ "String_Node_Str"+ this.parser.mode);
    }
  }
}

Fixed version (ground truth):
public final void parse(MarkerList markers,TokenIterator tokens){
  tokens.reset();
  this.tokens=tokens;
  IToken token=null;
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    SyntaxError ex) {
{
        if (ex.reparse) {
          this.reparse=true;
        }
        markers.add(ex);
      }
    }
catch (    Exception ex) {
{
        DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
        markers.add(new SyntaxError(token,"String_Node_Str" + token + "String_Node_Str"+ ex.getMessage()));
      }
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.name+ "String_Node_Str"+ this.parser.mode);
    }
  }
}
Program: 83327
Project: 83327
Buggy source:
@Override public void reset(){
  this.mode=PACKAGE | IMPORT;
}

Fixed version (ground truth):
@Override public void reset(){
  this.mode=PACKAGE;
}
Program: 83328
Project: 83328
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (token.type() == Symbols.SEMICOLON) {
    return;
  }
  if (this.isInMode(PACKAGE)) {
    if (this.parsePackage(pm,token)) {
      this.mode=IMPORT;
      return;
    }
  }
  if (this.isInMode(IMPORT)) {
    if (this.parseImport(pm,token)) {
      return;
    }
  }
  throw new SyntaxError(token,"String_Node_Str");
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (token.type() == Symbols.SEMICOLON) {
    return;
  }
switch (this.mode) {
case PACKAGE:
    if (this.parsePackage(pm,token)) {
      this.mode=IMPORT;
      return;
    }
case IMPORT:
  if (this.parseImport(pm,token)) {
    return;
  }
}
throw new SyntaxError(token,"String_Node_Str" + token + "String_Node_Str");
}
Program: 83329
Project: 83329
Buggy source:
public DyvilHeaderParser(IDyvilHeader unit){
  this.unit=unit;
  this.mode=PACKAGE | IMPORT;
}

Fixed version (ground truth):
public DyvilHeaderParser(IDyvilHeader unit){
  this.unit=unit;
  this.mode=PACKAGE;
}
Program: 83330
Project: 83330
Buggy source:
public DyvilUnitParser(IDyvilHeader unit){
  super(unit);
  this.mode=PACKAGE | IMPORT | CLASS;
}

Fixed version (ground truth):
public DyvilUnitParser(IDyvilHeader unit){
  super(unit);
  this.mode=PACKAGE;
}
Program: 83331
Project: 83331
Buggy source:
@Override public void reset(){
  this.mode=PACKAGE | IMPORT | CLASS;
}

Fixed version (ground truth):
@Override public void reset(){
  this.mode=PACKAGE;
}
Program: 83332
Project: 83332
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (this.isInMode(PACKAGE)) {
    if (this.parsePackage(pm,token)) {
      this.mode=IMPORT | CLASS;
      return;
    }
  }
  if (this.isInMode(IMPORT)) {
    if (this.parseImport(pm,token)) {
      this.mode=IMPORT | CLASS;
      return;
    }
  }
  if (this.isInMode(CLASS)) {
    if (type == Symbols.SEMICOLON) {
      return;
    }
    this.mode=CLASS;
    pm.pushParser(new ClassDeclarationParser(this.unit),true);
    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 (this.mode) {
case PACKAGE:
    if (this.parsePackage(pm,token)) {
      this.mode=IMPORT;
      return;
    }
case IMPORT:
  if (this.parseImport(pm,token)) {
    this.mode=IMPORT;
    return;
  }
case CLASS:
if (type == Symbols.SEMICOLON) {
  return;
}
this.mode=CLASS;
pm.pushParser(new ClassDeclarationParser(this.unit),true);
return;
}
throw new SyntaxError(token,"String_Node_Str");
}
Program: 83335
Project: 83335
Buggy source:
public void findUnits(File source,File output,Package pack){
  if (source.isDirectory()) {
    String name=source.getName();
    for (    String s : source.list()) {
      this.findUnits(new CodeFile(source,s),new File(output,s),pack == null ? Package.rootPackage : pack.createSubPackage(name));
    }
    return;
  }
  String fileName=source.getPath();
  if (!DyvilCompiler.config.compileFile(fileName)) {
    return;
  }
  if (fileName.endsWith("String_Node_Str") || fileName.endsWith("String_Node_Str")) {
    return;
  }
  this.files.add(output);
  String extension=fileName.substring(fileName.lastIndexOf('.') + 1);
  IFileType fileType=FileTypes.fileTypes.get(extension);
  if (fileType == null) {
    return;
  }
  ICompilationUnit unit=fileType.createUnit(pack,(CodeFile)source,output);
  if (unit == null) {
    return;
  }
  if (unit.isHeader()) {
    this.units.insert(0,unit);
  }
 else {
    this.units.add(unit);
  }
}

Fixed version (ground truth):
public void findUnits(File source,File output,Package pack){
  if (source.isDirectory()) {
    for (    String s : source.list()) {
      this.findUnits(new CodeFile(source,s),new File(output,s),pack.createSubPackage(s));
    }
    return;
  }
  String fileName=source.getPath();
  if (!DyvilCompiler.config.isExcluded(fileName)) {
    return;
  }
  if (fileName.endsWith("String_Node_Str") || fileName.endsWith("String_Node_Str")) {
    return;
  }
  this.files.add(output);
  String extension=fileName.substring(fileName.lastIndexOf('.') + 1);
  IFileType fileType=FileTypes.fileTypes.get(extension);
  if (fileType == null) {
    return;
  }
  ICompilationUnit unit=fileType.createUnit(pack,(CodeFile)source,output);
  if (unit == null) {
    return;
  }
  if (unit.isHeader()) {
    this.units.insert(0,unit);
  }
 else {
    this.units.add(unit);
  }
}
Program: 83336
Project: 83336
Buggy source:
public static boolean isTerminator2(int type){
  return type == Symbols.DOT || type == Symbols.COMMA || type == Symbols.SEMICOLON || type == Symbols.EQUALS || type == Keywords.IS || type == Keywords.AS || (type & Symbols.CLOSE_BRACKET) == Symbols.CLOSE_BRACKET || type == Symbols.OPEN_SQUARE_BRACKET || type == Tokens.STRING_PART || type == Tokens.STRING_END;
}

Fixed version (ground truth):
public static boolean isTerminator2(int type){
  return type == Symbols.DOT || type == Symbols.COMMA || type == Symbols.SEMICOLON || type == Symbols.COLON || type == Symbols.EQUALS || type == Keywords.IS || type == Keywords.AS || (type & Symbols.CLOSE_BRACKET) == Symbols.CLOSE_BRACKET || type == Symbols.OPEN_SQUARE_BRACKET || type == Tokens.STRING_PART || type == Tokens.STRING_END;
}
Program: 83337
Project: 83337
Buggy source:
public static boolean isTerminator(int type){
  return type == Symbols.COMMA || type == Symbols.SEMICOLON || (type & Symbols.CLOSE_BRACKET) == Symbols.CLOSE_BRACKET;
}

Fixed version (ground truth):
public static boolean isTerminator(int type){
  return type == Symbols.COMMA || type == Symbols.SEMICOLON || type == Symbols.COLON || (type & Symbols.CLOSE_BRACKET) == Symbols.CLOSE_BRACKET;
}
Program: 83338
Project: 83338
Buggy source:
private boolean computeVariable(REPLVariable field){
  this.getClassName();
  MarkerList markers=new MarkerList();
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    this.cleanup();
    return false;
  }
  field.cleanup(this,this);
  this.compileVariable(field);
  return true;
}

Fixed version (ground truth):
private boolean computeVariable(REPLVariable field){
  MarkerList markers=new MarkerList();
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    this.cleanup();
    return false;
  }
  field.cleanup(this,this);
  this.compileVariable(field);
  return true;
}
Program: 83339
Project: 83339
Buggy source:
private void compileVariable(REPLVariable field){
  field.foldConstants();
  this.compileInnerClasses();
  field.compute(this.currentClassName);
  this.cleanup();
}

Fixed version (ground truth):
private void compileVariable(REPLVariable field){
  field.foldConstants();
  this.compileInnerClasses();
  field.compute();
  this.cleanup();
}
Program: 83340
Project: 83340
Buggy source:
@Override public void addField(IField field){
  this.getClassName();
  REPLVariable var=new REPLVariable(field.getPosition(),field.getName(),field.getType(),field.getValue());
  var.setAnnotations(field.getAnnotations(),field.annotationCount());
  var.modifiers=field.getModifiers();
  if (this.computeVariable(var)) {
    this.variables.put(var.name,var);
    System.out.println(var.toString());
  }
}

Fixed version (ground truth):
@Override public void addField(IField field){
  String className=this.getClassName();
  REPLVariable var=new REPLVariable(field.getPosition(),field.getName(),field.getType(),field.getValue(),className);
  var.setAnnotations(field.getAnnotations(),field.annotationCount());
  var.modifiers=field.getModifiers();
  if (this.computeVariable(var)) {
    this.variables.put(var.name,var);
    System.out.println(var.toString());
  }
}
Program: 83341
Project: 83341
Buggy source:
@Override public void setValue(IValue value){
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  this.getClassName();
  MarkerList markers=new MarkerList();
  value.resolveTypes(markers,this);
  value=value.resolve(markers,this);
  IType type=value.getType();
  IValue value1=value.withType(type,type,markers,this);
  if (value1 == null) {
  }
 else {
    value=value1;
    type=value1.getType();
  }
  value.checkTypes(markers,this);
  value.check(markers,this);
  if (this.reportErrors(markers)) {
    this.cleanup();
    return;
  }
  value=value.cleanup(this,this);
  REPLVariable field=new REPLVariable(CODE_POSITION,name,type,value);
  field.modifiers=Modifiers.FINAL;
  this.compileVariable(field);
  if (type != Types.VOID) {
    this.variables.put(field.name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}

Fixed version (ground truth):
@Override public void setValue(IValue value){
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  String className=this.getClassName();
  MarkerList markers=new MarkerList();
  value.resolveTypes(markers,this);
  value=value.resolve(markers,this);
  IType type=value.getType();
  IValue value1=value.withType(type,type,markers,this);
  if (value1 == null) {
  }
 else {
    value=value1;
    type=value1.getType();
  }
  value.checkTypes(markers,this);
  value.check(markers,this);
  if (this.reportErrors(markers)) {
    this.cleanup();
    return;
  }
  value=value.cleanup(this,this);
  REPLVariable field=new REPLVariable(CODE_POSITION,name,type,value,className);
  field.modifiers=Modifiers.FINAL;
  this.compileVariable(field);
  if (type != Types.VOID) {
    this.variables.put(field.name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}
Program: 83342
Project: 83342
Buggy source:
protected void compute(String className){
  List<IClassCompilable> compilableList=DyvilREPL.context.compilableList;
  if (this.className != null || (this.isConstant() && !compilableList.isEmpty())) {
    return;
  }
  try {
    this.className=className;
    Class c=this.generateClass(this.className,compilableList);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}

Fixed version (ground truth):
protected void compute(){
  List<IClassCompilable> compilableList=DyvilREPL.context.compilableList;
  if (this.isConstant() && !compilableList.isEmpty()) {
    return;
  }
  try {
    Class c=this.generateClass(this.className,compilableList);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}
Program: 83343
Project: 83343
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) throws BytecodeException {
  if (this.className == null) {
    writer.writeInsn(Opcodes.AUTO_POP);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.PUTSTATIC,this.className,"String_Node_Str",extended);
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) 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);
}
Program: 83344
Project: 83344
Buggy source:
public REPLVariable(ICodePosition position,Name name,IType type,IValue value){
  super(null,name,type);
  this.position=position;
  this.value=value;
}

Fixed version (ground truth):
public REPLVariable(ICodePosition position,Name name,IType type,IValue value,String className){
  super(null,name,type);
  this.className=className;
  this.theClass=new REPLMemberClass(Name.getQualified(className),this);
  this.position=position;
  this.value=value;
}