nus-yam/ex-repair huggingface dataset:
Program: 83416
Project: 83416
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    if (this.type == Types.UNKNOWN) {
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
      return;
    }
    IValue value1=this.value.withType(this.type,null,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    if (this.type == Types.UNKNOWN) {
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
    }
    IValue value1=this.value.withType(this.type,null,markers,context);
    if (value1 == null) {
      Marker marker=markers.create(this.value.getPosition(),"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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}
Program: 83417
Project: 83417
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
  }
  if (this.type == Types.UNKNOWN) {
    this.type=this.value.getType();
    if (this.type == Types.UNKNOWN) {
      markers.add(this.position,"String_Node_Str",this.name.unqualified);
    }
    return;
  }
  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;
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
  }
  if (this.type == Types.UNKNOWN) {
    this.type=this.value.getType();
    if (this.type == Types.UNKNOWN) {
      markers.add(this.position,"String_Node_Str",this.name.unqualified);
    }
  }
  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;
  }
}
Program: 83418
Project: 83418
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);
    if (this.type == Types.UNKNOWN) {
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
      return;
    }
    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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}

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);
    if (this.type == Types.UNKNOWN) {
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
    }
    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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}
Program: 83419
Project: 83419
Buggy source:
private void checkTypeVarsInferred(MarkerList markers,ITypeContext typeContext){
  for (int i=0; i < this.genericCount; i++) {
    ITypeVariable typeVar=this.generics[i];
    IType type=typeContext.resolveType(typeVar);
    if (type == null || (type.typeTag() == IType.TYPE_VAR_TYPE && ((TypeVarType)type).typeVar == typeVar)) {
      markers.add(position,"String_Node_Str",this.name,typeVar.getName());
      typeContext.addMapping(typeVar,Types.ANY);
    }
  }
}

Fixed version (ground truth):
private void checkTypeVarsInferred(MarkerList markers,ICodePosition position,ITypeContext typeContext){
  for (int i=0; i < this.genericCount; i++) {
    ITypeVariable typeVar=this.generics[i];
    IType type=typeContext.resolveType(typeVar);
    if (type == null || (type.typeTag() == IType.TYPE_VAR_TYPE && ((TypeVarType)type).typeVar == typeVar)) {
      markers.add(position,"String_Node_Str",this.name,typeVar.getName());
      typeContext.addMapping(typeVar,Types.ANY);
    }
  }
}
Program: 83421
Project: 83421
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);
    if (this.type == Types.UNKNOWN) {
      this.type=this.defaultValue.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
      return;
    }
    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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue=this.defaultValue.resolve(markers,context);
    if (this.type == Types.UNKNOWN) {
      this.type=this.defaultValue.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
    }
    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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}
Program: 83422
Project: 83422
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.defaultValue != null) {
    context.getThisClass().addCompilable(this);
    this.defaultValue=this.defaultValue.resolve(markers,context);
    if (this.type == Types.UNKNOWN) {
      this.type=this.defaultValue.getType();
      if (this.type == Types.UNKNOWN) {
        markers.add(this.position,"String_Node_Str",this.name.unqualified);
      }
      return;
    }
    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;
    }
    return;
  }
  if (this.type == Types.UNKNOWN) {
    markers.add(this.position,"String_Node_Str",this.name.unqualified);
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  super.resolve(markers,context);
  if (this.defaultValue != null) {
    context.getThisClass().addCompilable(this);
    this.defaultValue=this.defaultValue.resolve(markers,context);
    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;
    }
    return;
  }
}
Program: 83423
Project: 83423
Buggy source:
@Override public void writeTypeExpression(MethodWriter writer) throws BytecodeException {
  if (this.bound != null) {
    this.bound.writeTypeExpression(writer);
  }
 else {
    writer.writeInsn(Opcodes.ACONST_NULL);
  }
  writer.writeInvokeInsn(Opcodes.INVOKESTATIC,"String_Node_Str","String_Node_Str","String_Node_Str",false);
}

Fixed version (ground truth):
@Override public void writeTypeExpression(MethodWriter writer) throws BytecodeException {
  writer.writeFieldInsn(Opcodes.GETSTATIC,"String_Node_Str",this.variance.name(),"String_Node_Str");
  if (this.bound != null) {
    this.bound.writeTypeExpression(writer);
  }
 else {
    writer.writeInsn(Opcodes.ACONST_NULL);
  }
  writer.writeInvokeInsn(Opcodes.INVOKESTATIC,"String_Node_Str","String_Node_Str","String_Node_Str",false);
}
Program: 83424
Project: 83424
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type == null) {
    this.type=Types.UNKNOWN;
    markers.add(this.position,"String_Node_Str");
    return;
  }
  this.type=this.type.resolve(markers,context,TypePosition.TYPE);
  GenericType generic=new GenericType(Types.CLASS_CLASS);
  generic.addType(this.type);
  this.genericType=generic;
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type == null) {
    this.type=Types.UNKNOWN;
    markers.add(this.position,"String_Node_Str");
    return;
  }
  this.type=this.type.resolve(markers,context,TypePosition.CLASS);
  GenericType generic=new GenericType(Types.CLASS_CLASS);
  generic.addType(this.type);
  this.genericType=generic;
}
Program: 83425
Project: 83425
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type == null) {
    this.type=Types.UNKNOWN;
    markers.add(this.position,"String_Node_Str");
    return;
  }
  this.type=this.type.resolve(markers,context,TypePosition.GENERIC_ARGUMENT);
  GenericType generic=new GenericType(Types.TYPE_CLASS);
  generic.addType(this.type);
  this.genericType=generic;
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type == null) {
    this.type=Types.UNKNOWN;
    markers.add(this.position,"String_Node_Str");
    return;
  }
  this.type=this.type.resolve(markers,context,TypePosition.TYPE);
  GenericType generic=new GenericType(Types.TYPE_CLASS);
  generic.addType(this.type);
  this.genericType=generic;
}
Program: 83426
Project: 83426
Buggy source:
@Override public boolean isSuperTypeOf(IType type){
  IClass iclass=getTupleClass(this.typeCount);
  if (!iclass.isSubTypeOf(type)) {
    return false;
  }
  for (int i=0; i < this.typeCount; i++) {
    ITypeVariable typeVar=iclass.getTypeVariable(i);
    IType type1=type.resolveType(typeVar);
    if (!type1.isSuperTypeOf(this.types[i])) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isSuperTypeOf(IType type){
  IClass iclass=getTupleClass(this.typeCount);
  if (!iclass.isSubTypeOf(type)) {
    return false;
  }
  for (int i=0; i < this.typeCount; i++) {
    ITypeVariable typeVar=iclass.getTypeVariable(i);
    IType type1=type.resolveType(typeVar);
    if (!this.types[i].isSuperTypeOf(type1)) {
      return false;
    }
  }
  return true;
}
Program: 83428
Project: 83428
Buggy source:
@Override public void appendGenericSignature(StringBuilder builder){
  if (this.lowerBound != null) {
    builder.append('-');
    this.lowerBound.appendGenericSignature(builder);
    return;
  }
  if (this.upperBound != null) {
    builder.append('+');
    this.upperBound.appendSignature(builder);
    return;
  }
  builder.append('*');
}

Fixed version (ground truth):
@Override public void appendGenericSignature(StringBuilder builder){
  if (this.bound != null) {
    if (this.variance == Variance.CONTRAVARIANT) {
      builder.append('-');
    }
 else {
      builder.append('+');
    }
    this.bound.appendSignature(builder);
    return;
  }
  builder.append('*');
}
Program: 83429
Project: 83429
Buggy source:
public WildcardType(Type lowerBound,Type upperBounds){
  this.lowerBound=lowerBound;
  this.upperBound=upperBounds;
}

Fixed version (ground truth):
public WildcardType(Variance variance,Type bound){
  this.variance=variance;
  this.bound=bound;
}
Program: 83430
Project: 83430
Buggy source:
public static <T>WildcardType<T> apply(Type lowerBound,Type upperBounds){
  return new WildcardType(lowerBound,upperBounds);
}

Fixed version (ground truth):
public static <T>WildcardType<T> apply(Variance variance,Type upperBounds){
  return new WildcardType(variance,upperBounds);
}
Program: 83431
Project: 83431
Buggy source:
@Override public void appendSignature(StringBuilder builder){
  if (this.lowerBound != null) {
    builder.append("String_Node_Str");
    return;
  }
  if (this.upperBound != null) {
    this.upperBound.appendSignature(builder);
  }
}

Fixed version (ground truth):
@Override public void appendSignature(StringBuilder builder){
  if (this.bound != null && this.variance == Variance.COVARIANT) {
    this.bound.appendSignature(builder);
    return;
  }
  builder.append("String_Node_Str");
}
Program: 83432
Project: 83432
Buggy source:
@Override public void toString(StringBuilder builder){
  builder.append('_');
  if (this.lowerBound != null) {
    builder.append("String_Node_Str");
    this.lowerBound.toString(builder);
  }
  if (this.upperBound != null) {
    builder.append("String_Node_Str");
    this.upperBound.toString(builder);
  }
}

Fixed version (ground truth):
@Override public void toString(StringBuilder builder){
  builder.append('_');
  if (this.bound != null) {
    if (this.variance == Variance.CONTRAVARIANT) {
      builder.append("String_Node_Str");
    }
 else {
      builder.append("String_Node_Str");
    }
    this.bound.toString(builder);
  }
}
Program: 83433
Project: 83433
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (this.superType != null) {
    IType type=this.superType.resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    IType type=this.interfaces[i].resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (this.superType != null) {
    IType type=this.superType.resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    IType type=this.interfaces[i].resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  return Types.ANY;
}
Program: 83434
Project: 83434
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  IType type;
  for (int i=0; i < this.upperBoundCount; i++) {
    type=this.upperBounds[i].resolveType(typeVar,concrete);
    if (type != null) {
      return type;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  IType type;
  for (int i=0; i < this.upperBoundCount; i++) {
    type=this.upperBounds[i].resolveType(typeVar,concrete);
    if (type != null) {
      return type;
    }
  }
  return Types.ANY;
}
Program: 83435
Project: 83435
Buggy source:
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex >= 0) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  }
  writer.writeInvokeInsn(Opcodes.INVOKEVIRTUAL,this.boxingMethod.getTheClass().getInternalName(),this.boxingMethod.getName().qualified,this.boxingMethod.getDescriptor(),false);
  this.pattern.writeInvJump(writer,-1,elseLabel);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex >= 0) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  }
  this.boxingMethod.writeInvoke(writer,null,null);
  this.pattern.writeInvJump(writer,-1,elseLabel);
}
Program: 83436
Project: 83436
Buggy source:
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex >= 0) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  }
  writer.writeInvokeInsn(Opcodes.INVOKEVIRTUAL,this.boxingMethod.getTheClass().getInternalName(),this.boxingMethod.getName().qualified,this.boxingMethod.getDescriptor(),false);
  this.pattern.writeJump(writer,-1,elseLabel);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex >= 0) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  }
  this.boxingMethod.writeInvoke(writer,null,null);
  this.pattern.writeJump(writer,-1,elseLabel);
}
Program: 83437
Project: 83437
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  return concrete.isArrayType() ? this.type.resolveType(typeVar,concrete.getElementType()) : null;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  return concrete.isArrayType() ? this.type.resolveType(typeVar,concrete.getElementType()) : Types.ANY;
}
Program: 83438
Project: 83438
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  IType type;
  if (concrete.typeTag() != GENERIC) {
    return null;
  }
  GenericType gt=(GenericType)concrete;
  if (gt.typeArgumentCount != this.typeArgumentCount) {
    return null;
  }
  for (int i=0; i < this.typeArgumentCount; i++) {
    type=this.typeArguments[i].resolveType(typeVar,gt.typeArguments[i]);
    if (type != null) {
      return type;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  IType type;
  if (concrete.typeTag() != GENERIC) {
    return Types.ANY;
  }
  GenericType gt=(GenericType)concrete;
  if (gt.typeArgumentCount != this.typeArgumentCount) {
    return Types.ANY;
  }
  for (int i=0; i < this.typeArgumentCount; i++) {
    type=this.typeArguments[i].resolveType(typeVar,gt.typeArguments[i]);
    if (type != null) {
      return type;
    }
  }
  return Types.ANY;
}
Program: 83439
Project: 83439
Buggy source:
/** 
 * Returns the type argument in this generic type for the given type variable, where this is the template containing the type variable types and   {@code concrete} contains the concrete types.<p> Example:<br> <pre> GenericType gt1 = type[List].genericType // => List[E] GenericType gt2 = type[List[String]] ITypeVariable tv = type[List].getTypeVariable("E") gt1.resolveType(tv, gt2) // => String </pre>
 */
public default IType resolveType(ITypeVariable typeVar,IType concrete){
  return null;
}

Fixed version (ground truth):
/** 
 * Returns the type argument in this generic type for the given type variable, where this is the template containing the type variable types and   {@code concrete} contains the concrete types.<p> Example:<br> <pre> GenericType gt1 = type[List].genericType // => List[E] GenericType gt2 = type[List[String]] ITypeVariable tv = type[List].getTypeVariable("E") gt1.resolveType(tv, gt2) // => String </pre>
 */
public default IType resolveType(ITypeVariable typeVar,IType concrete){
  return Types.ANY;
}
Program: 83440
Project: 83440
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (concrete.typeTag() != LAMBDA) {
    return null;
  }
  LambdaType lambdaType=(LambdaType)concrete;
  if (lambdaType.parameterCount != this.parameterCount) {
    return null;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IType concreteType=lambdaType.parameterTypes[i];
    IType type=this.parameterTypes[i].resolveType(typeVar,concreteType);
    if (type != null) {
      return type;
    }
  }
  return this.returnType.resolveType(typeVar,lambdaType.returnType);
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (concrete.typeTag() != LAMBDA) {
    return Types.ANY;
  }
  LambdaType lambdaType=(LambdaType)concrete;
  if (lambdaType.parameterCount != this.parameterCount) {
    return Types.ANY;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IType concreteType=lambdaType.parameterTypes[i];
    IType type=this.parameterTypes[i].resolveType(typeVar,concreteType);
    if (type != null) {
      return type;
    }
  }
  return this.returnType.resolveType(typeVar,lambdaType.returnType);
}
Program: 83441
Project: 83441
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  return null;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  return Types.ANY;
}
Program: 83444
Project: 83444
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  this.field.writeGet(writer,this.instance);
  writer.writeInsn(this.field.getType().getReturnOpcode());
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeInsn(this.field.getType().getReturnOpcode());
}
Program: 83445
Project: 83445
Buggy source:
@Override public int getTypeMatch(IType type){
  if (this.field == null) {
    return 0;
  }
  IType type1=this.field.getType();
  if (type.equals(type1)) {
    return 3;
  }
  if (type.isSuperTypeOf(type1)) {
    return 2;
  }
  return 0;
}

Fixed version (ground truth):
@Override public int getTypeMatch(IType type){
  if (this.field == null) {
    return 0;
  }
  IType type1=this.getType();
  if (type.equals(type1)) {
    return 3;
  }
  if (type.isSuperTypeOf(type1)) {
    return 2;
  }
  return 0;
}
Program: 83446
Project: 83446
Buggy source:
@Override public boolean isType(IType type){
  return this.field == null ? false : type.isSuperTypeOf(this.field.getType());
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  return this.field == null ? false : type.isSuperTypeOf(this.getType());
}
Program: 83447
Project: 83447
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.field.writeGet(writer,this.instance);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  this.field.writeGet(writer,this.instance);
  if (!this.type.isSuperTypeOf(this.field.getType())) {
    writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
  }
}
Program: 83448
Project: 83448
Buggy source:
@Override public IType getType(){
  return this.field == null ? Types.UNKNOWN : this.field.getType();
}

Fixed version (ground truth):
@Override public IType getType(){
  if (this.type == null) {
    if (this.field == null) {
      return Types.UNKNOWN;
    }
    if (this.instance == null) {
      return this.type=this.field.getType();
    }
    return this.type=this.field.getType().getConcreteType(this.instance.getType());
  }
  return this.type;
}
Program: 83449
Project: 83449
Buggy source:
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (this.superType != null) {
    IType type=this.superType.resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    IType type=this.interfaces[i].resolveType(typeVar);
    if (type != null) {
      return type.getConcreteType(concrete);
    }
  }
  return Types.ANY;
}

Fixed version (ground truth):
@Override public IType resolveType(ITypeVariable typeVar,IType concrete){
  if (this.superType != null) {
    IType type=this.superType.resolveType(typeVar);
    if (type != Types.ANY) {
      return type.getConcreteType(concrete);
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    IType type=this.interfaces[i].resolveType(typeVar);
    if (type != Types.ANY) {
      return type.getConcreteType(concrete);
    }
  }
  return Types.ANY;
}
Program: 83450
Project: 83450
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.BOOLEAN) {
    return this;
  }
  if (type.isSuperTypeOf(Types.BOOLEAN)) {
    return new BoxedValue(this,Types.BOOLEAN.boxMethod);
  }
  if (type.getTheClass().getAnnotation(BOOLEAN_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.BOOLEAN) {
    return this;
  }
  if (type.isSuperTypeOf(Types.BOOLEAN)) {
    return new BoxedValue(this,Types.BOOLEAN.boxMethod);
  }
  if (type.getTheClass().getAnnotation(BOOLEAN_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83451
Project: 83451
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.CHAR) {
    return this;
  }
  if (type.isSuperTypeOf(Types.CHAR)) {
    return new BoxedValue(this,Types.CHAR.boxMethod);
  }
  if (type.getTheClass().getAnnotation(CHAR_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.CHAR) {
    return this;
  }
  if (type.isSuperTypeOf(Types.CHAR)) {
    return new BoxedValue(this,Types.CHAR.boxMethod);
  }
  if (type.getTheClass().getAnnotation(CHAR_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83452
Project: 83452
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.DOUBLE) {
    return this;
  }
  if (type.isSuperTypeOf(Types.DOUBLE)) {
    return new BoxedValue(this,Types.DOUBLE.boxMethod);
  }
  if (type.getTheClass().getAnnotation(DOUBLE_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.DOUBLE) {
    return this;
  }
  if (type.isSuperTypeOf(Types.DOUBLE)) {
    return new BoxedValue(this,Types.DOUBLE.boxMethod);
  }
  if (type.getTheClass().getAnnotation(DOUBLE_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83453
Project: 83453
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.FLOAT) {
    return this;
  }
  if (type.isSuperTypeOf(Types.FLOAT)) {
    return new BoxedValue(this,Types.FLOAT.boxMethod);
  }
  if (type.getTheClass().getAnnotation(FLOAT_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.FLOAT) {
    return this;
  }
  if (type.isSuperTypeOf(Types.FLOAT)) {
    return new BoxedValue(this,Types.FLOAT.boxMethod);
  }
  if (type.getTheClass().getAnnotation(FLOAT_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83454
Project: 83454
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.INT) {
    return this;
  }
  if (type.isSuperTypeOf(Types.INT)) {
    return new BoxedValue(this,Types.INT.boxMethod);
  }
  if (type.getTheClass().getAnnotation(INT_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.INT) {
    return this;
  }
  if (type.isSuperTypeOf(Types.INT)) {
    return new BoxedValue(this,Types.INT.boxMethod);
  }
  if (type.getTheClass().getAnnotation(INT_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83455
Project: 83455
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.LONG) {
    return this;
  }
  if (type.isSuperTypeOf(Types.LONG)) {
    return new BoxedValue(this,Types.LONG.boxMethod);
  }
  if (type.getTheClass().getAnnotation(LONG_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type == Types.LONG) {
    return this;
  }
  if (type.isSuperTypeOf(Types.LONG)) {
    return new BoxedValue(this,Types.LONG.boxMethod);
  }
  if (type.getTheClass().getAnnotation(LONG_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83456
Project: 83456
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  if (type.getTheClass().getAnnotation(STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  if (type.getTheClass().getAnnotation(STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83457
Project: 83457
Buggy source:
@Override public IValue withType(IType arrayType,ITypeContext typeContext,MarkerList markers,IContext context){
  if (!arrayType.isArrayType()) {
    IClass iclass=arrayType.getTheClass();
    if (iclass == Types.OBJECT_CLASS || iclass == null) {
      return this;
    }
    if (iclass.getAnnotation(ARRAY_CONVERTIBLE) != null) {
      return new LiteralExpression(arrayType,this);
    }
    return null;
  }
  IType 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){
  if (!arrayType.isArrayType()) {
    IClass iclass=arrayType.getTheClass();
    if (iclass == Types.OBJECT_CLASS || iclass == null) {
      return this;
    }
    if (iclass.getAnnotation(ARRAY_CONVERTIBLE) != null) {
      return new LiteralExpression(this).withType(arrayType,typeContext,markers,context);
    }
    return null;
  }
  IType 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;
}
Program: 83458
Project: 83458
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  IClass iclass=type.getTheClass();
  if (iclass.getAnnotation(StringValue.STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  if (iclass.getAnnotation(FORMAT_STRING_CONVERTIBLE) != null) {
    StringValue string;
    int len=this.count / 2;
    if (len > 0) {
      StringBuilder builder=new StringBuilder();
      builder.append(this.strings[0]);
      for (int i=1; i <= len; i++) {
        builder.append('\\').append(i);
        builder.append(this.strings[i]);
      }
      string=new StringValue(this.position,builder.toString());
    }
 else {
      string=new StringValue("String_Node_Str");
    }
    ArgumentList list=new ArgumentList(1 + len);
    list.addValue(string);
    for (int i=0; i < len; i++) {
      list.addValue(this.values[i]);
    }
    return new LiteralExpression(type,list);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  IClass iclass=type.getTheClass();
  if (iclass.getAnnotation(StringValue.STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  if (iclass.getAnnotation(FORMAT_STRING_CONVERTIBLE) != null) {
    StringValue string;
    int len=this.count / 2;
    if (len > 0) {
      StringBuilder builder=new StringBuilder();
      builder.append(this.strings[0]);
      for (int i=1; i <= len; i++) {
        builder.append('\\').append(i);
        builder.append(this.strings[i]);
      }
      string=new StringValue(this.position,builder.toString());
    }
 else {
      string=new StringValue("String_Node_Str");
    }
    ArgumentList list=new ArgumentList(1 + len);
    list.addValue(string);
    for (int i=0; i < len; i++) {
      list.addValue(this.values[i]);
    }
    return new LiteralExpression(list).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83460
Project: 83460
Buggy source:
@Override public boolean isType(IType type){
  if (this.type != null && type.isSuperTypeOf(this.type)) {
    return true;
  }
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType paramType=lambdaParam.getType();
    if (paramType == null) {
      continue;
    }
    if (!param.getType().equals(paramType)) {
      return false;
    }
  }
  this.type=type;
  this.method=method;
  return true;
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (this.type != null && type.isSuperTypeOf(this.type)) {
    return true;
  }
  IClass iclass=type.getTheClass();
  if (iclass == null) {
    return false;
  }
  IMethod method=iclass.getFunctionalMethod();
  if (method == null) {
    return false;
  }
  if (this.parameterCount != method.parameterCount()) {
    return false;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter lambdaParam=this.parameters[i];
    IParameter param=method.getParameter(i);
    IType lambdaParamType=lambdaParam.getType();
    if (lambdaParamType == null) {
      continue;
    }
    if (!param.getType().equals(lambdaParamType)) {
      return false;
    }
  }
  return true;
}
Program: 83461
Project: 83461
Buggy source:
public LiteralExpression(IType type,IArguments arguments){
  this.type=type;
  this.arguments=arguments;
}

Fixed version (ground truth):
public LiteralExpression(IArguments arguments){
  this.arguments=arguments;
}
Program: 83462
Project: 83462
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IMethod method=IContext.resolveMethod(type,null,Name.apply,this.arguments);
  if (method == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
    this.type=type;
  }
 else {
    this.method=method;
    GenericData data=method.getGenericData(null,null,this.arguments);
    method.checkArguments(markers,null,context,null,this.arguments,data);
    this.type=method.getType().getConcreteType(data);
    if (!type.isSuperTypeOf(this.type)) {
      Marker m=markers.create(this.arguments.getFirstValue().getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + type);
      m.addInfo("String_Node_Str" + this.type);
      StringBuilder sb=new StringBuilder("String_Node_Str");
      Util.methodSignatureToString(method,sb);
      m.addInfo(sb.toString());
    }
  }
  return this;
}
Program: 83463
Project: 83463
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(this.type,null,Name.apply,this.arguments);
  if (match == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
  }
 else {
    this.method=match;
    GenericData data=match.getGenericData(null,null,this.arguments);
    match.checkArguments(markers,null,context,null,this.arguments,data);
    this.type=match.getType().getConcreteType(data);
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.arguments.checkTypes(markers,context);
}
Program: 83464
Project: 83464
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  if (type.getTheClass().getAnnotation(StringValue.STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(type,this);
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isSuperTypeOf(Types.STRING)) {
    return this;
  }
  if (type.getTheClass().getAnnotation(StringValue.STRING_CONVERTIBLE) != null) {
    return new LiteralExpression(this).withType(type,typeContext,markers,context);
  }
  return null;
}
Program: 83465
Project: 83465
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(desc));
  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){
  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);
}
Program: 83466
Project: 83466
Buggy source:
private void resolveReturnType(){
  this.returnTypeResolved=true;
  this.type=this.type.resolve(null,Package.rootPackage);
}

Fixed version (ground truth):
private void resolveReturnType(){
  this.returnTypeResolved=true;
  this.type=this.type.resolve(null,this.theClass);
}
Program: 83468
Project: 83468
Buggy source:
protected boolean argumentsMatch(IType type){
  for (int i=0; i < this.typeArgumentCount; i++) {
    ITypeVariable typeVar=this.theClass.getTypeVariable(i);
    IType otherType=type.resolveType(typeVar);
    if (!this.typeArguments[i].equals(otherType)) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
protected boolean argumentsMatch(IType type){
  int count=this.theClass.genericCount();
  for (int i=0; i < count; i++) {
    ITypeVariable typeVar=this.theClass.getTypeVariable(i);
    IType otherType=type.resolveType(typeVar);
    if (!this.typeArguments[i].equals(otherType)) {
      return false;
    }
  }
  return true;
}
Program: 83469
Project: 83469
Buggy source:
private static int getMode(char c,String code,int i){
switch (c) {
case '`':
    return SPECIAL_IDENTIFIER;
case '#':
  if (code.charAt(i + 1) == '[') {
    return GENERIC_CALL;
  }
return IDENTIFIER | MOD_SYMBOL;
case '"':
return STRING;
case '\'':
return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_2;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}

Fixed version (ground truth):
private static int getMode(char c,String code,int i){
switch (c) {
case '`':
    return SPECIAL_IDENTIFIER;
case '#':
  if (code.charAt(i + 1) == '[') {
    return GENERIC_CALL;
  }
return IDENTIFIER | MOD_SYMBOL;
case '"':
return STRING;
case '\'':
return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_2;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
case '_':
case '$':
return IDENTIFIER | MOD_SYMBOL | MOD_LETTER;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}
Program: 83471
Project: 83471
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (type == Symbols.SEMICOLON && token.isInferred()) {
    pm.popParser(true);
    return;
  }
  if (this.mode == 0) {
    this.mode=1;
    pm.pushParser(new TypeParser(this),true);
    return;
  }
  if (this.mode == 1) {
    if (ParserUtil.isCloseBracket(type)) {
      pm.popParser(true);
      return;
    }
    this.mode=0;
    if (ParserUtil.isSeperator(type)) {
      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 ((type == Symbols.SEMICOLON && token.isInferred()) || type == Symbols.OPEN_CURLY_BRACKET) {
    pm.popParser(true);
    return;
  }
  if (this.mode == 0) {
    this.mode=1;
    pm.pushParser(new TypeParser(this),true);
    return;
  }
  if (this.mode == 1) {
    if (ParserUtil.isCloseBracket(type)) {
      pm.popParser(true);
      return;
    }
    this.mode=0;
    if (ParserUtil.isSeperator(type)) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
}