nus-yam/ex-repair huggingface dataset:
Program: 83233
Project: 83233
Buggy source:
void generate(MethodType methodType){
  this.visitCode();
  if (AnonymousClassLMF.this.implKind == MethodHandleInfo.REF_newInvokeSpecial) {
    this.visitTypeInsn(NEW,AnonymousClassLMF.this.implMethodClassName);
    this.visitInsn(DUP);
  }
  for (int i=0; i < AnonymousClassLMF.this.argNames.length; i++) {
    this.visitVarInsn(ALOAD,0);
    this.visitFieldInsn(GETFIELD,AnonymousClassLMF.this.lambdaClassName,AnonymousClassLMF.this.argNames[i],AnonymousClassLMF.this.argDescs[i]);
  }
  this.convertArgumentTypes(methodType);
  this.visitMethodInsn(this.invocationOpcode(),AnonymousClassLMF.this.implMethodClassName,AnonymousClassLMF.this.implMethodName,AnonymousClassLMF.this.implMethodDesc,AnonymousClassLMF.this.implDefiningClass.isInterface());
  Class<?> samReturnClass=methodType.returnType();
  TypeConverter.convertType(this,AnonymousClassLMF.this.implMethodReturnClass,samReturnClass,samReturnClass);
  this.visitInsn(getReturnOpcode(samReturnClass));
  this.visitMaxs(-1,-1);
  this.visitEnd();
}

Fixed version (ground truth):
void generate(MethodType methodType){
  this.mv.visitCode();
  if (AnonymousClassLMF.this.implKind == MethodHandleInfo.REF_newInvokeSpecial) {
    this.mv.visitTypeInsn(NEW,AnonymousClassLMF.this.implMethodClassName);
    this.mv.visitInsn(DUP);
  }
  for (int i=0; i < AnonymousClassLMF.this.argNames.length; i++) {
    this.mv.visitVarInsn(ALOAD,0);
    this.mv.visitFieldInsn(GETFIELD,AnonymousClassLMF.this.lambdaClassName,AnonymousClassLMF.this.argNames[i],AnonymousClassLMF.this.argDescs[i]);
  }
  this.convertArgumentTypes(methodType);
  this.mv.visitMethodInsn(this.invocationOpcode(),AnonymousClassLMF.this.implMethodClassName,AnonymousClassLMF.this.implMethodName,AnonymousClassLMF.this.implMethodDesc,AnonymousClassLMF.this.implDefiningClass.isInterface());
  Class<?> samReturnClass=methodType.returnType();
  TypeConverter.convertType(this.mv,AnonymousClassLMF.this.implMethodReturnClass,samReturnClass,samReturnClass);
  this.mv.visitInsn(getReturnOpcode(samReturnClass));
  this.mv.visitMaxs(-1,-1);
  this.mv.visitEnd();
}
Program: 83234
Project: 83234
Buggy source:
ForwardingMethodGenerator(MethodVisitor mv){
  super(dyvil.tools.asm.Opcodes.ASM5,mv);
}

Fixed version (ground truth):
ForwardingMethodGenerator(MethodVisitor mv){
  this.mv=mv;
}
Program: 83236
Project: 83236
Buggy source:
public IType getElementType(){
  if (this.elementType != null) {
    return this.elementType;
  }
  int len=this.valueCount;
  if (len == 0) {
    this.elementType=Types.ANY;
    return this.requiredType=new ArrayType(Types.ANY);
  }
  IType t=this.values[0].getType();
  for (int i=1; i < len; i++) {
    IType t1=this.values[i].getType();
    t=Types.combine(t,t1);
    if (t == null) {
      t=Types.ANY;
      break;
    }
  }
  return this.elementType=t;
}

Fixed version (ground truth):
public IType getElementType(){
  if (this.elementType != null) {
    return this.elementType;
  }
  int len=this.valueCount;
  if (len == 0) {
    return this.elementType=Types.ANY;
  }
  IType t=this.values[0].getType();
  for (int i=1; i < len; i++) {
    IType t1=this.values[i].getType();
    t=Types.combine(t,t1);
    if (t == null) {
      t=Types.ANY;
      break;
    }
  }
  return this.elementType=t;
}
Program: 83238
Project: 83238
Buggy source:
@Override public IValue withType(IType arrayType,ITypeContext typeContext,MarkerList markers,IContext context){
  IType elementType;
  if (!arrayType.isArrayType()) {
    IClass iclass=arrayType.getTheClass();
    if (iclass.getAnnotation(Types.ARRAY_CONVERTIBLE) != null) {
      return new LiteralExpression(this).withType(arrayType,typeContext,markers,context);
    }
    if (arrayType.classEquals(Types.ITERABLE)) {
      return new LiteralExpression(this,getArrayToIterable()).withType(arrayType,typeContext,markers,context);
    }
 else     if (iclass != Types.OBJECT_CLASS) {
      return null;
    }
 else {
      elementType=this.getElementType();
    }
  }
 else {
    elementType=arrayType.getElementType();
  }
  for (int i=0; i < this.valueCount; i++) {
    if (!this.values[i].isType(elementType)) {
      return null;
    }
  }
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
  }
  this.elementType=elementType;
  this.requiredType=arrayType;
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType arrayType,ITypeContext typeContext,MarkerList markers,IContext context){
  IType elementType;
  if (!arrayType.isArrayType()) {
    IClass iclass=arrayType.getTheClass();
    if (iclass.getAnnotation(Types.ARRAY_CONVERTIBLE) != null) {
      return new LiteralExpression(this).withType(arrayType,typeContext,markers,context);
    }
    if (arrayType.classEquals(Types.ITERABLE)) {
      return new LiteralExpression(this,getArrayToIterable()).withType(arrayType,typeContext,markers,context);
    }
 else     if (iclass != Types.OBJECT_CLASS) {
      return null;
    }
 else {
      elementType=this.getElementType();
    }
  }
 else {
    elementType=arrayType.getElementType();
  }
  for (int i=0; i < this.valueCount; i++) {
    if (!this.values[i].isType(elementType)) {
      return null;
    }
  }
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
  }
  if (arrayType.hasTypeVariables()) {
    this.getType();
    return this;
  }
  this.elementType=elementType;
  this.requiredType=arrayType;
  return this;
}
Program: 83239
Project: 83239
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.then == null) {
    return null;
  }
  IValue then1=this.then.withType(type,typeContext,markers,context);
  if (then1 == null) {
    return null;
  }
  this.then=then1;
  if (this.elseThen != null) {
    then1=this.elseThen.withType(type,typeContext,markers,context);
    if (then1 == null) {
      return null;
    }
    this.elseThen=then1;
  }
  this.commonType=type;
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.then == null) {
    return null;
  }
  IValue then1=this.then.withType(type,typeContext,markers,context);
  if (then1 == null) {
    return null;
  }
  this.then=then1;
  if (this.elseThen != null) {
    then1=this.elseThen.withType(type,typeContext,markers,context);
    if (then1 == null) {
      return null;
    }
    this.elseThen=then1;
    this.commonType=Types.combine(this.then.getType(),this.elseThen.getType());
    return this;
  }
  this.commonType=this.then.getType();
  return this;
}
Program: 83240
Project: 83240
Buggy source:
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  if (this.condition != null) {
    this.condition=this.condition.cleanup(context,compilableList);
  }
  if (this.then != null) {
    this.then=this.then.cleanup(context,compilableList);
  }
  if (this.elseThen != null) {
    this.elseThen=this.elseThen.cleanup(context,compilableList);
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue cleanup(IContext context,IClassCompilableList compilableList){
  if (this.condition != null) {
    this.condition=this.condition.cleanup(context,compilableList);
  }
  if (this.then != null) {
    this.then=this.then.cleanup(context,compilableList);
  }
  if (this.elseThen != null) {
    this.elseThen=this.elseThen.cleanup(context,compilableList);
  }
  if ((this.condition.valueTag() == BOOLEAN)) {
    return ((BooleanValue)this.condition).value ? this.then : this.elseThen;
  }
  return this;
}
Program: 83241
Project: 83241
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.VOID || type == Types.UNKNOWN) {
    this.requiredType=Types.VOID;
    return this;
  }
  if (this.valueCount > 0) {
    IValue v=this.values[this.valueCount - 1].withType(type,typeContext,markers,context);
    if (v != null) {
      this.values[this.valueCount - 1]=v;
      this.requiredType=type;
      return this;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.VOID) {
    this.requiredType=Types.VOID;
    return this;
  }
  if (this.valueCount > 0) {
    IValue v=this.values[this.valueCount - 1].withType(type,typeContext,markers,context);
    if (v != null) {
      this.values[this.valueCount - 1]=v;
      this.requiredType=v.getType();
      return this;
    }
  }
  return null;
}
Program: 83242
Project: 83242
Buggy source:
public static IType combine(IType type1,IType type2){
  if (type1.equals(type2)) {
    return type1;
  }
  Set<IType> types1=superTypes(type1);
  Set<IType> types2=superTypes(type2);
  for (  IType t1 : types1) {
    IClass class1=t1.getTheClass();
    if (class1 == Types.OBJECT_CLASS) {
      continue;
    }
    for (    IType t2 : types2) {
      if (class1 == t2.getTheClass()) {
        return new ClassType(class1);
      }
    }
  }
  return Types.ANY;
}

Fixed version (ground truth):
public static IType combine(IType type1,IType type2){
  if (type1.equals(type2)) {
    return type1;
  }
  if (type1.typeTag() == IType.NULL) {
    return type2.getReferenceType();
  }
  if (type2.typeTag() == IType.NULL) {
    return type1.getReferenceType();
  }
  Set<IType> types1=superTypes(type1);
  Set<IType> types2=superTypes(type2);
  for (  IType t1 : types1) {
    IClass class1=t1.getTheClass();
    if (class1 == Types.OBJECT_CLASS) {
      continue;
    }
    for (    IType t2 : types2) {
      if (class1 == t2.getTheClass()) {
        return new ClassType(class1);
      }
    }
  }
  return Types.ANY;
}
Program: 83244
Project: 83244
Buggy source:
@Override public void check(){
  this.pack.check(this.packageDeclaration,this.inputFile,this.markers);
}

Fixed version (ground truth):
@Override public void check(){
  this.pack.check(this.packageDeclaration,this.markers);
}
Program: 83245
Project: 83245
Buggy source:
@Override public void check(){
  this.pack.check(this.packageDeclaration,this.inputFile,this.markers);
  for (int i=0; i < this.classCount; i++) {
    this.classes[i].check(this.markers,this);
  }
}

Fixed version (ground truth):
@Override public void check(){
  this.pack.check(this.packageDeclaration,this.markers);
  for (int i=0; i < this.classCount; i++) {
    this.classes[i].check(this.markers,this);
  }
}
Program: 83246
Project: 83246
Buggy source:
public void check(PackageDeclaration packageDecl,CodeFile file,MarkerList markers){
  if (packageDecl == null) {
    if (this.fullName != null) {
      markers.add(new CodePosition(0,0,1),"String_Node_Str");
    }
    return;
  }
  if (this.fullName == null) {
    markers.add(packageDecl.getPosition(),"String_Node_Str");
    return;
  }
  if (!this.fullName.equals(packageDecl.thePackage)) {
    markers.add(packageDecl.getPosition(),"String_Node_Str");
  }
}

Fixed version (ground truth):
public void check(PackageDeclaration packageDecl,MarkerList markers){
  if (packageDecl == null) {
    markers.add(new CodePosition(0,0,1),"String_Node_Str");
    return;
  }
  if (!this.fullName.equals(packageDecl.thePackage)) {
    markers.add(packageDecl.getPosition(),"String_Node_Str",this.fullName);
  }
}
Program: 83247
Project: 83247
Buggy source:
public Package(Package parent,Name name){
  this.name=name;
  this.parent=parent;
  if (parent == null || parent.name == null) {
    this.fullName=name.qualified;
    this.internalName=ClassFormat.packageToInternal(name.qualified) + "String_Node_Str";
  }
 else {
    this.fullName=parent.fullName + "String_Node_Str" + name.qualified;
    this.internalName=parent.internalName + name.qualified + "String_Node_Str";
  }
}

Fixed version (ground truth):
public Package(Package parent,Name name){
  this.name=name;
  this.parent=parent;
  if (parent == null || parent == rootPackage) {
    this.fullName=name.qualified;
    this.internalName=ClassFormat.packageToInternal(name.qualified) + "String_Node_Str";
  }
 else {
    this.fullName=parent.fullName + "String_Node_Str" + name.qualified;
    this.internalName=parent.internalName + name.qualified + "String_Node_Str";
  }
}
Program: 83248
Project: 83248
Buggy source:
public RootPackage(){
}

Fixed version (ground truth):
public RootPackage(){
  this.internalName=this.fullName="String_Node_Str";
  this.name=Name.getQualified("String_Node_Str");
}
Program: 83249
Project: 83249
Buggy source:
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,Name name,IArguments arguments){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  this.body.getMethodMatches(list,instance,name,arguments);
  if (!list.isEmpty()) {
    return;
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null && this.superType.getTheClass() != Types.OBJECT_CLASS) {
    this.superType.getMethodMatches(list,instance,name,arguments);
  }
  if (!list.isEmpty()) {
    return;
  }
  for (int i=0; i < this.interfaceCount; i++) {
    this.interfaces[i].getMethodMatches(list,instance,name,arguments);
  }
}

Fixed version (ground truth):
@Override public void getMethodMatches(List<MethodMatch> list,IValue instance,Name name,IArguments arguments){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  this.body.getMethodMatches(list,instance,name,arguments);
  if (!list.isEmpty()) {
    return;
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    this.superType.getMethodMatches(list,instance,name,arguments);
  }
  if (!list.isEmpty()) {
    return;
  }
  for (int i=0; i < this.interfaceCount; i++) {
    this.interfaces[i].getMethodMatches(list,instance,name,arguments);
  }
}
Program: 83250
Project: 83250
Buggy source:
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 - 1; 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: 83251
Project: 83251
Buggy source:
public static void readMethodType(String desc,IMethodSignature method){
  int i=1;
  if (desc.charAt(0) == '<') {
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,method);
    }
    i+=2;
  }
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,method);
  }
  i++;
  i=readTyped(desc,i,method);
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,method);
  }
}

Fixed version (ground truth):
public static void readMethodType(String desc,IMethodSignature method){
  int i=1;
  if (desc.charAt(0) == '<') {
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,method);
    }
    i+=2;
  }
  while (desc.charAt(i) != ')') {
    i=readTyped(desc,i,method::addType);
  }
  i++;
  i=readTyped(desc,i,method);
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,method);
  }
}
Program: 83252
Project: 83252
Buggy source:
private static int readGeneric(String desc,int start,IGeneric generic){
  int index=desc.indexOf(':',start);
  Name name=Name.getQualified(desc.substring(start,index));
  TypeVariable typeVar=new TypeVariable(generic,name);
  if (desc.charAt(index + 1) == ':') {
    index++;
    typeVar.addUpperBound(Types.OBJECT);
  }
  while (desc.charAt(index) == ':') {
    index=readTypeList(desc,index + 1,typeVar);
  }
  generic.addTypeVariable(typeVar);
  return index;
}

Fixed version (ground truth):
private static int readGeneric(String desc,int start,IGeneric generic){
  int index=desc.indexOf(':',start);
  Name name=Name.getQualified(desc.substring(start,index));
  TypeVariable typeVar=new TypeVariable(generic,name);
  if (desc.charAt(index + 1) == ':') {
    index++;
    typeVar.addUpperBound(Types.OBJECT);
  }
  while (desc.charAt(index) == ':') {
    index=readTyped(desc,index + 1,typeVar::addUpperBound);
  }
  generic.addTypeVariable(typeVar);
  return index;
}
Program: 83253
Project: 83253
Buggy source:
public static void readConstructorType(String desc,IConstructor constructor){
  int i=1;
  while (desc.charAt(i) != ')') {
    i=readTypeList(desc,i,constructor);
  }
  i+=2;
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,constructor);
  }
}

Fixed version (ground truth):
public static void readConstructorType(String desc,IConstructor constructor){
  int i=1;
  while (desc.charAt(i) != ')') {
    i=readTyped(desc,i,constructor::addType);
  }
  i+=2;
  int len=desc.length();
  while (i < len && desc.charAt(i) == '^') {
    i=readException(desc,i + 1,constructor);
  }
}
Program: 83254
Project: 83254
Buggy source:
private static IType readReferenceType(String desc,int start,int end){
  int index=desc.indexOf('<',start);
  if (index >= 0 && index < end) {
    GenericType type=new InternalGenericType(desc.substring(start,index));
    index++;
    while (desc.charAt(index) != '>') {
      index=readTypeList(desc,index,type);
    }
    return type;
  }
  return new InternalType(desc.substring(start,end));
}

Fixed version (ground truth):
private static IType readReferenceType(String desc,int start,int end){
  int index=desc.indexOf('<',start);
  if (index >= 0 && index < end) {
    GenericType type=new InternalGenericType(desc.substring(start,index));
    index++;
    while (desc.charAt(index) != '>') {
      index=readTyped(desc,index,type);
    }
    return type;
  }
  return new InternalType(desc.substring(start,end));
}
Program: 83255
Project: 83255
Buggy source:
public static void readClassSignature(String desc,IClass iclass){
  int i=0;
  if (desc.charAt(0) == '<') {
    i++;
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,iclass);
    }
    i++;
  }
  int len=desc.length();
  i=readTyped(desc,i,iclass);
  while (i < len) {
    i=readTyped(desc,i,t -> iclass.addInterface(t));
  }
}

Fixed version (ground truth):
public static void readClassSignature(String desc,IClass iclass){
  int i=0;
  if (desc.charAt(0) == '<') {
    i++;
    while (desc.charAt(i) != '>') {
      i=readGeneric(desc,i,iclass);
    }
    i++;
  }
  int len=desc.length();
  i=readTyped(desc,i,iclass::setSuperType);
  while (i < len) {
    i=readTyped(desc,i,iclass::addInterface);
  }
}
Program: 83257
Project: 83257
Buggy source:
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  super.cleanup(context,compilableList);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].cleanup(this,compilableList);
  }
  if (this.value != null) {
    this.value=this.value.cleanup(this,compilableList);
    if (this.theClass.isInterface() && !this.isStatic()) {
      this.modifiers|=Modifiers.BRIDGE | Modifiers.SYNTHETIC;
    }
  }
}

Fixed version (ground truth):
@Override public void cleanup(IContext context,IClassCompilableList compilableList){
  super.cleanup(context,compilableList);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].cleanup(this,compilableList);
  }
  if (this.value != null) {
    this.value=this.value.cleanup(this,compilableList);
  }
}
Program: 83259
Project: 83259
Buggy source:
@Override public boolean isEmpty(){
  return false;
}

Fixed version (ground truth):
@Override public boolean isEmpty(){
  return this.value == null;
}
Program: 83261
Project: 83261
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  for (int i=0; i < this.caseCount; i++) {
    CaseExpression c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.pattern;
    if (pattern == null) {
      continue;
    }
    pattern=pattern.resolve(markers,context);
    if (pattern.isExhaustive()) {
      if (c.condition == null) {
        this.exhaustive=true;
      }
    }
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
 else {
      pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
    c.pattern=pattern;
    this.cases[i].resolve(markers,context);
  }
  if (type == Types.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  for (int i=0; i < this.caseCount; i++) {
    CaseExpression c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.pattern;
    if (pattern == null) {
      continue;
    }
    pattern=pattern.resolve(markers,context);
    if (pattern.isExhaustive()) {
      if (c.condition == null) {
        this.exhaustive=true;
      }
    }
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
 else {
      pattern=pattern1;
    }
    c.pattern=pattern;
    this.cases[i].resolve(markers,context);
  }
  if (type == Types.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}
Program: 83262
Project: 83262
Buggy source:
public FieldVisitor visitField(int access,String name,String desc,String signature,Object value){
  Field field=new ExternalField(this);
  field.setName(Name.get(name));
  field.setModifiers(access);
  field.setType(ClassFormat.extendedToType(signature == null ? desc : signature));
  if (value != null) {
    field.setValue(IValue.fromObject(value));
  }
  if ((this.modifiers & Modifiers.OBJECT_CLASS) != 0 && name.equals("String_Node_Str")) {
    this.metadata.setInstanceField(field);
    return null;
  }
  this.body.addField(field);
  return new SimpleFieldVisitor(field);
}

Fixed version (ground truth):
public FieldVisitor visitField(int access,String name,String desc,String signature,Object value){
  IType type=ClassFormat.extendedToType(signature == null ? desc : signature);
  if (this.classParameters != null) {
    for (    String s : this.classParameters) {
      if (s.equals(name)) {
        ClassParameter param=new ClassParameter(this,access,Name.get(name),type);
        this.addParameter(param);
        return new SimpleFieldVisitor(param);
      }
    }
  }
  ExternalField field=new ExternalField(this,access,Name.get(name),type);
  if (value != null) {
    field.setValue(IValue.fromObject(value));
  }
  if ((this.modifiers & Modifiers.OBJECT_CLASS) != 0 && name.equals("String_Node_Str")) {
    this.getMetadata().setInstanceField(field);
  }
 else {
    this.body.addField(field);
  }
  return new SimpleFieldVisitor(field);
}
Program: 83263
Project: 83263
Buggy source:
@Override public IDataMember resolveField(Name name){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  IDataMember field=this.body.getProperty(name);
  if (field != null) {
    return field;
  }
  field=this.body.getField(name);
  if (field != null) {
    return field;
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    IDataMember match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IDataMember resolveField(Name name){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    if (param.getName() == name) {
      return param;
    }
  }
  IDataMember field=this.body.getProperty(name);
  if (field != null) {
    return field;
  }
  field=this.body.getField(name);
  if (field != null) {
    return field;
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    IDataMember match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}
Program: 83264
Project: 83264
Buggy source:
public ExternalField(IClass iclass){
  super(iclass);
}

Fixed version (ground truth):
public ExternalField(IClass iclass,int access,Name name,IType type){
  super(iclass,name,type);
  this.modifiers=access;
}
Program: 83265
Project: 83265
Buggy source:
@Override public void addImport(IImport iimport){
  int index=this.importCount++;
  if (index >= this.imports.length) {
    IImport[] temp=new IImport[index];
    System.arraycopy(this.imports,0,temp,0,this.imports.length);
    this.imports=temp;
  }
  this.imports[index]=iimport;
}

Fixed version (ground truth):
@Override public void addImport(IImport iimport){
  int index=this.importCount++;
  if (index >= this.imports.length) {
    IImport[] temp=new IImport[index + 1];
    System.arraycopy(this.imports,0,temp,0,this.imports.length);
    this.imports=temp;
  }
  this.imports[index]=iimport;
}
Program: 83266
Project: 83266
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue=this.defaultValue.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.defaultValue.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.defaultValue.withType(this.type,null,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.defaultValue.getPosition(),"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.defaultValue.getType());
    }
 else {
      this.defaultValue=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){
  this.modifiers|=Modifiers.PUBLIC;
  super.resolve(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue=this.defaultValue.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.defaultValue.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
        this.type=Types.ANY;
      }
    }
    IValue value1=this.defaultValue.withType(this.type,null,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.defaultValue.getPosition(),"String_Node_Str",this.name.unqualified);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.defaultValue.getType());
    }
 else {
      this.defaultValue=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: 83267
Project: 83267
Buggy source:
public ClassParameter(Name name,IType type){
  this.name=name;
  this.type=type;
}

Fixed version (ground truth):
public ClassParameter(IClass theClass,int access,Name name,IType type){
  this.theClass=theClass;
  this.name=name;
  this.type=type;
  this.modifiers=access;
}
Program: 83268
Project: 83268
Buggy source:
@Override public void visitEnd(){
}

Fixed version (ground truth):
@Override public void visitEnd(){
  this.theClass.visitEnd();
}
Program: 83269
Project: 83269
Buggy source:
@Override public AnnotationVisitor visitAnnotation(String name,boolean visible){
  String internal=ClassFormat.extendedToInternal(name);
  if (this.theClass.addRawAnnotation(internal)) {
    Annotation annotation=new Annotation(null,ClassFormat.internalToType(internal));
    return new AnnotationVisitorImpl(this.theClass,annotation);
  }
  return null;
}

Fixed version (ground truth):
@Override public AnnotationVisitor visitAnnotation(String type,boolean visible){
  return this.theClass.visitAnnotation(type,visible);
}
Program: 83274
Project: 83274
Buggy source:
@Override public void compile(){
  if (ICompilationUnit.printMarkers(this.markers,"String_Node_Str",this.name,this.inputFile)) {
    return;
  }
  HeaderFile.write(this.outputFile,this);
}

Fixed version (ground truth):
@Override public void compile(){
  if (this.printMarkers()) {
    return;
  }
  HeaderFile.write(this.outputFile,this);
}
Program: 83275
Project: 83275
Buggy source:
@Override public void compile(){
  if (ICompilationUnit.printMarkers(this.markers,"String_Node_Str",this.name,this.inputFile)) {
    return;
  }
  for (int i=0; i < this.classCount; i++) {
    IClass iclass=this.classes[i];
    String name=iclass.getName().qualified;
    if (!name.equals(this.name)) {
      name=this.name + "String_Node_Str" + name+ "String_Node_Str";
    }
 else {
      name+="String_Node_Str";
    }
    File file=new File(this.outputDirectory,name);
    ClassWriter.compile(file,iclass);
    IClassBody body=iclass.getBody();
    if (body != null) {
      int len=body.classCount();
      for (int j=0; j < len; j++) {
        IClass iclass1=body.getClass(j);
        name=this.name + "String_Node_Str" + iclass1.getName().qualified+ "String_Node_Str";
        file=new File(this.outputDirectory,name);
        ClassWriter.compile(file,iclass1);
      }
    }
  }
  for (int i=0; i < this.innerClassCount; i++) {
    IClassCompilable iclass=this.innerClasses[i];
    String name=iclass.getFileName() + "String_Node_Str";
    File file=new File(this.outputDirectory,name);
    ClassWriter.compile(file,iclass);
  }
}

Fixed version (ground truth):
@Override public void compile(){
  if (this.printMarkers()) {
    return;
  }
  for (int i=0; i < this.classCount; i++) {
    IClass iclass=this.classes[i];
    String name=iclass.getName().qualified;
    if (!name.equals(this.name)) {
      name=this.name + "String_Node_Str" + name+ "String_Node_Str";
    }
 else {
      name+="String_Node_Str";
    }
    File file=new File(this.outputDirectory,name);
    ClassWriter.compile(file,iclass);
    IClassBody body=iclass.getBody();
    if (body != null) {
      int len=body.classCount();
      for (int j=0; j < len; j++) {
        IClass iclass1=body.getClass(j);
        name=this.name + "String_Node_Str" + iclass1.getName().qualified+ "String_Node_Str";
        file=new File(this.outputDirectory,name);
        ClassWriter.compile(file,iclass1);
      }
    }
  }
  for (int i=0; i < this.innerClassCount; i++) {
    IClassCompilable iclass=this.innerClasses[i];
    String name=iclass.getFileName() + "String_Node_Str";
    File file=new File(this.outputDirectory,name);
    ClassWriter.compile(file,iclass);
  }
}
Program: 83276
Project: 83276
Buggy source:
public void findUnits(FileFinder fileFinder){
  if (!this.includedFiles.isEmpty()) {
    for (    String s : this.includedFiles) {
      File source=new File(sourceDir,s);
      File output=new File(outputDir,s);
      Package pack=packageFromFile(s,source.isDirectory());
      fileFinder.findUnits(source,output,pack);
    }
    return;
  }
  fileFinder.findUnits(sourceDir,outputDir,Package.rootPackage);
}

Fixed version (ground truth):
public void findUnits(FileFinder fileFinder){
  if (!this.includedFiles.isEmpty()) {
    for (    String s : this.includedFiles) {
      File source=new File(sourceDir,s);
      File output=new File(outputDir,s);
      Package pack=packageFromFile(s,source.isDirectory());
      fileFinder.process(source,output,pack);
    }
    return;
  }
  fileFinder.process(sourceDir,outputDir,Package.rootPackage);
}
Program: 83277
Project: 83277
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (this.mode == NAME) {
    if (ParserUtil.isIdentifier(type)) {
      Name name=token.nameValue();
      this.annotation.name=name;
      this.annotation.type=new NamedType(token.raw(),name);
      this.mode=PARAMETERS_START;
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == PARAMETERS_START) {
    if (type == Symbols.OPEN_PARENTHESIS) {
      IToken next=token.next();
      if (ParserUtil.isIdentifier(next.type()) && next.next().type() == Symbols.COLON) {
        ArgumentMap map=new ArgumentMap();
        this.annotation.arguments=map;
        pm.pushParser(new ExpressionMapParser(map));
      }
 else {
        ArgumentList list=new ArgumentList();
        this.annotation.arguments=list;
        pm.pushParser(new ExpressionListParser(list));
      }
      this.mode=PARAMETERS_END;
      return;
    }
    if (type == Symbols.OPEN_SQUARE_BRACKET) {
      SingleArgument arg=new SingleArgument();
      this.annotation.arguments=arg;
      pm.popParser();
      pm.pushParser(new ExpressionParser(arg),true);
      return;
    }
    pm.popParser(true);
    return;
  }
  if (this.mode == PARAMETERS_END) {
    if (type == Symbols.CLOSE_PARENTHESIS) {
      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();
  if (this.mode == NAME) {
    if (ParserUtil.isIdentifier(type)) {
      Name name=token.nameValue();
      this.annotation.name=name;
      this.annotation.type=new NamedType(token.raw(),name);
      this.mode=PARAMETERS_START;
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == PARAMETERS_START) {
    if (type == Symbols.OPEN_PARENTHESIS) {
      IToken next=token.next();
      if (ParserUtil.isIdentifier(next.type()) && next.next().type() == Symbols.COLON) {
        ArgumentMap map=new ArgumentMap();
        this.annotation.arguments=map;
        pm.pushParser(new ExpressionMapParser(map));
      }
 else {
        ArgumentList list=new ArgumentList();
        this.annotation.arguments=list;
        pm.pushParser(new ExpressionListParser(list));
      }
      this.mode=PARAMETERS_END;
      return;
    }
    if (type == Symbols.OPEN_SQUARE_BRACKET) {
      SingleArgument arg=new SingleArgument();
      this.annotation.arguments=arg;
      pm.popParser();
      pm.pushParser(pm.newExpressionParser(arg),true);
      return;
    }
    pm.popParser(true);
    return;
  }
  if (this.mode == PARAMETERS_END) {
    if (type == Symbols.CLOSE_PARENTHESIS) {
      pm.popParser();
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
}
Program: 83281
Project: 83281
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar){
  int index=typeVar.getIndex();
  if (this.method.getTypeVariable(index) == 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.method.getTypeVariable(index) == typeVar) {
    if (index > this.genericCount) {
      return new TypeVarType(typeVar);
    }
    return this.generics[index];
  }
  return this.instanceType.resolveType(typeVar);
}
Program: 83282
Project: 83282
Buggy source:
@Override public void addMapping(ITypeVariable typeVar,IType type){
  int index=typeVar.getIndex();
  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.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;
}
Program: 83284
Project: 83284
Buggy source:
@Override public IClass getTheClass(){
  return null;
}

Fixed version (ground truth):
@Override public IClass getTheClass(){
  return NULL_CLASS;
}
Program: 83285
Project: 83285
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.foldConstants();
  this.compileInnerClasses();
  field.compute(this.currentClassName);
  this.cleanup();
  return true;
}

Fixed version (ground truth):
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;
  }
  this.compileVariable(field);
  return true;
}
Program: 83286
Project: 83286
Buggy source:
@Override public void setValue(IValue value){
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  REPLVariable field=new REPLVariable(CODE_POSITION,name,Types.UNKNOWN,value);
  field.modifiers=Modifiers.FINAL;
  if (this.computeVariable(field)) {
    if (field.getType() != 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);
  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;
  }
  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++;
  }
}
Program: 83287
Project: 83287
Buggy source:
@Override public IConstructor getConstructor(int index){
  return this.constructors[index];
}

Fixed version (ground truth):
@Override public IConstructor getConstructor(IParameter[] parameters,int parameterCount){
  outer:   for (int i=0; i < this.constructorCount; i++) {
    IConstructor c=this.constructors[i];
    if (c.parameterCount() != parameterCount) {
      continue;
    }
    for (int p=0; p < parameterCount; p++) {
      IType classParamType=parameters[p].getType();
      IType constructorParamType=c.getParameter(p).getType();
      if (!classParamType.equals(constructorParamType)) {
        continue outer;
      }
    }
    return c;
  }
  return null;
}
Program: 83288
Project: 83288
Buggy source:
public ClassMetadata(IClass iclass){
  this.theClass=iclass;
  Constructor constructor=new Constructor(this.theClass);
  constructor.modifiers=Modifiers.PUBLIC;
  this.constructor=constructor;
}

Fixed version (ground truth):
public ClassMetadata(IClass iclass){
  this.theClass=iclass;
}
Program: 83289
Project: 83289
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IType superType=this.theClass.getSuperType();
  if (superType == null) {
    return;
  }
  IConstructor match=IContext.resolveConstructor(superType,EmptyArguments.INSTANCE);
  if (match != null) {
    this.superConstructor=match;
    return;
  }
  markers.add(this.theClass.getPosition(),"String_Node_Str",superType.toString());
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if ((this.methods & CONSTRUCTOR) != 0) {
    return;
  }
  IType superType=this.theClass.getSuperType();
  if (superType == null) {
    return;
  }
  IConstructor match=IContext.resolveConstructor(superType,EmptyArguments.INSTANCE);
  if (match != null) {
    this.superConstructor=match;
    return;
  }
  markers.add(this.theClass.getPosition(),"String_Node_Str",superType.toString());
}
Program: 83290
Project: 83290
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  this.constructor.type=this.theClass.getType();
  int parameterCount=this.theClass.parameterCount();
  IParameter[] parameters=this.theClass.getParameters();
  this.constructor.setParameters(parameters,parameterCount);
  if (parameterCount > 0 && parameters[parameterCount - 1].isVarargs()) {
    this.constructor.setVarargs();
  }
}

Fixed version (ground truth):
@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;
}
Program: 83291
Project: 83291
Buggy source:
@Override public void getConstructorMatches(List<ConstructorMatch> list,IArguments arguments){
  int match=this.constructor.getSignatureMatch(arguments);
  if (match > 0) {
    list.add(new ConstructorMatch(this.constructor,match));
  }
}

Fixed version (ground truth):
@Override public void getConstructorMatches(List<ConstructorMatch> list,IArguments arguments){
  if ((this.methods & CONSTRUCTOR) != 0) {
    return;
  }
  int match=this.constructor.getSignatureMatch(arguments);
  if (match > 0) {
    list.add(new ConstructorMatch(this.constructor,match));
  }
}
Program: 83292
Project: 83292
Buggy source:
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  StatementList list=new StatementList();
  if (instanceFields != null) {
    list.addValue(instanceFields);
  }
  if (this.superConstructor != null) {
    list.addValue(new InitializerCall(null,this.superConstructor,EmptyArguments.INSTANCE,true));
  }
  int count=this.theClass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=this.theClass.getParameter(i);
    list.addValue(new ClassParameterSetter(this.theClass,param));
  }
  this.constructor.setValue(list);
  this.constructor.write(writer,instanceFields);
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  if ((this.methods & CONSTRUCTOR) != 0) {
    return;
  }
  StatementList list=new StatementList();
  if (instanceFields != null) {
    list.addValue(instanceFields);
  }
  if (this.superConstructor != null) {
    list.addValue(new InitializerCall(null,this.superConstructor,EmptyArguments.INSTANCE,true));
  }
  int count=this.theClass.parameterCount();
  for (int i=0; i < count; i++) {
    IParameter param=this.theClass.getParameter(i);
    list.addValue(new ClassParameterSetter(this.theClass,param));
  }
  this.constructor.setValue(list);
  this.constructor.write(writer,instanceFields);
}
Program: 83293
Project: 83293
Buggy source:
@Override public IType resolveType(Name name){
  if (name == this.name) {
    return new ClassType(this);
  }
  for (int i=0; i < this.genericCount; i++) {
    ITypeVariable var=this.generics[i];
    if (var.getName() == name) {
      return new TypeVarType(var);
    }
  }
  return this.unit.resolveType(name);
}

Fixed version (ground truth):
@Override public IType resolveType(Name name){
  if (name == this.name) {
    return new ClassType(this);
  }
  if (this.body != null) {
    IClass iclass=this.body.getClass(name);
    if (iclass != null) {
      return new ClassType(iclass);
    }
  }
  for (int i=0; i < this.genericCount; i++) {
    ITypeVariable var=this.generics[i];
    if (var.getName() == name) {
      return new TypeVarType(var);
    }
  }
  if (this.outerClass != null) {
    return this.outerClass.resolveType(name);
  }
  return this.unit.resolveType(name);
}
Program: 83294
Project: 83294
Buggy source:
@Override public IClass resolveClass(Name name){
  if (this.body != null) {
    IClass clazz=this.body.getClass(name);
    if (clazz != null) {
      return clazz;
    }
  }
  if (this.outerClass != null) {
    return this.outerClass.resolveClass(name);
  }
  return this.unit.resolveClass(name);
}

Fixed version (ground truth):
@Override public IClass resolveClass(Name name){
  if (this.body != null) {
    IClass iclass=this.body.getClass(name);
    if (iclass != null) {
      return iclass;
    }
  }
  if (this.outerClass != null) {
    return this.outerClass.resolveClass(name);
  }
  return this.unit.resolveClass(name);
}
Program: 83295
Project: 83295
Buggy source:
public IConstructor getConstructor(int index);

Fixed version (ground truth):
public IConstructor getConstructor(IParameter[] parameters,int parameterCount);