nus-yam/ex-repair huggingface dataset:
Program: 82938
Project: 82938
Buggy source:
/** 
 * @return the specialized method type of the SAM method, as opposed to{@link IMethod#getDescriptor()}.
 */
private String getSpecialDescriptor(){
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  this.returnType.appendExtendedName(buffer);
  return buffer.toString();
}

Fixed version (ground truth):
/** 
 * @return the specialized method type of the SAM method, as opposed to {@link IMethod#getDescriptor()}.
 */
private String getSpecialDescriptor(){
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  this.returnType.appendExtendedName(buffer);
  return buffer.toString();
}
Program: 82939
Project: 82939
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,context);
  }
  this.value.resolveTypes(markers,new CombiningContext(this,context));
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    if (param.getType() == Types.UNKNOWN) {
      param.setType(null);
      param.resolveTypes(markers,context);
      param.setType(Types.UNKNOWN);
    }
 else {
      param.resolveTypes(markers,context);
    }
  }
  this.value.resolveTypes(markers,new CombiningContext(this,context));
}
Program: 82940
Project: 82940
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  this.value.check(markers,context);
  ModifierUtil.checkModifiers(markers,this,this.modifiers,Modifiers.VARIABLE_MODIFIERS);
  if (this.type == Types.VOID) {
    markers.add(Markers.semantic(this.position,"String_Node_Str"));
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  this.value.check(markers,context);
  if (this.modifiers != null) {
    ModifierUtil.checkModifiers(markers,this,this.modifiers,Modifiers.VARIABLE_MODIFIERS);
  }
  if (this.type == Types.VOID) {
    markers.add(Markers.semantic(this.position,"String_Node_Str"));
  }
}
Program: 82941
Project: 82941
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  ModifierUtil.checkModifiers(markers,this,this.modifiers,Modifiers.PARAMETER_MODIFIERS);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
  if (this.type == Types.VOID) {
    markers.add(Markers.semantic(this.position,this.getKind().getName() + "String_Node_Str"));
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  super.check(markers,context);
  if (this.defaultValue != null) {
    this.defaultValue.check(markers,context);
  }
  if (this.type == Types.VOID) {
    markers.add(Markers.semantic(this.position,this.getKind().getName() + "String_Node_Str"));
  }
}
Program: 82942
Project: 82942
Buggy source:
protected void compute(DyvilREPL repl,List<IClassCompilable> compilableList){
  if (this.isConstant() && !compilableList.isEmpty()) {
    return;
  }
  try {
    this.theClass=this.generateClass(this.className,compilableList);
    this.updateValue(repl);
  }
 catch (  Throwable t) {
    filterStackTrace(t);
    t.printStackTrace(repl.getOutput());
  }
}

Fixed version (ground truth):
protected void compute(DyvilREPL repl,List<IClassCompilable> compilableList){
  if (this.isConstant() && !compilableList.isEmpty()) {
    return;
  }
  try {
    this.theClass=this.generateClass(this.className,compilableList);
  }
 catch (  Throwable throwable) {
    throwable.printStackTrace(repl.getErrorOutput());
  }
  try {
    this.updateValue(repl);
  }
 catch (  Throwable t) {
    filterStackTrace(t);
    t.printStackTrace(repl.getOutput());
  }
}
Program: 82943
Project: 82943
Buggy source:
@Override public boolean isUsableAsStatement(){
  for (int i=0; i < this.caseCount; i++) {
    if (!this.cases[i].action.isUsableAsStatement()) {
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean isUsableAsStatement(){
  for (int i=0; i < this.caseCount; i++) {
    final IValue action=this.cases[i].action;
    if (action != null && !action.isUsableAsStatement()) {
      return false;
    }
  }
  return true;
}
Program: 82944
Project: 82944
Buggy source:
@Override public void resolveStatement(ILabelContext context,MarkerList markers){
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].action.resolveStatement(context,markers);
  }
}

Fixed version (ground truth):
@Override public void resolveStatement(ILabelContext context,MarkerList markers){
  for (int i=0; i < this.caseCount; i++) {
    final IValue action=this.cases[i].action;
    if (action != null) {
      action.resolveStatement(context,markers);
    }
  }
}
Program: 82945
Project: 82945
Buggy source:
public static void parse(String content,Map<String,Object> map){
  Parser parser=new Parser(new MarkerList(),content);
  FlatMapConverter converter=new FlatMapConverter(map);
  parser.parseFileNode(converter);
}

Fixed version (ground truth):
public static void parse(String content,Map<String,Object> map){
  Parser parser=new Parser(new MarkerList(),content);
  FlatMapConverter converter=new FlatMapConverter(map);
  parser.parseNodeBody(converter);
}
Program: 82946
Project: 82946
Buggy source:
private void parseNodeBody(NodeVisitor visitor){
  while (true) {
    if (!(this.tokens.hasNext() && this.parseNodeElement(visitor))) {
      break;
    }
  }
  visitor.visitEnd();
}

Fixed version (ground truth):
public void parseNodeBody(NodeVisitor visitor){
  while (true) {
    if (!(this.tokens.hasNext() && this.parseNodeElement(visitor))) {
      break;
    }
  }
  visitor.visitEnd();
}
Program: 82947
Project: 82947
Buggy source:
public Parser(MarkerList markers,String code){
  this.markers=markers;
  DyvilLexer lexer=new DyvilLexer(markers,BaseSymbols.INSTANCE);
  this.tokens=lexer.tokenize(code);
}

Fixed version (ground truth):
public Parser(MarkerList markers,String code){
  this.markers=markers;
  final DyvilLexer lexer=new DyvilLexer(markers,BaseSymbols.INSTANCE);
  this.tokens=lexer.tokenize(code);
}
Program: 82948
Project: 82948
Buggy source:
private void parseParameters(BuilderVisitor visitor){
  IToken token=this.tokens.lastReturned().next();
  if (token.type() == BaseSymbols.CLOSE_PARENTHESIS) {
    this.tokens.next();
    visitor.visitEnd();
    return;
  }
  while (this.tokens.hasNext()) {
    if (token.next().type() == BaseSymbols.COLON) {
      this.tokens.next();
      this.tokens.next();
      this.parseValue(visitor.visitParameter(token.nameValue()));
    }
 else {
      this.parseValue(visitor.visitParameter(null));
    }
    token=this.tokens.next();
switch (token.type()) {
case BaseSymbols.CLOSE_PARENTHESIS:
      visitor.visitEnd();
    return;
case BaseSymbols.COMMA:
case BaseSymbols.SEMICOLON:
  token=token.next();
continue;
}
}
}

Fixed version (ground truth):
private void parseParameters(BuilderVisitor visitor){
  IToken token=this.tokens.lastReturned().next();
  if (token.type() == BaseSymbols.CLOSE_PARENTHESIS) {
    this.tokens.next();
    visitor.visitEnd();
    return;
  }
  while (this.tokens.hasNext()) {
    if (token.next().type() == BaseSymbols.COLON) {
      this.tokens.next();
      this.tokens.next();
      this.parseValue(visitor.visitParameter(token.nameValue()));
    }
 else {
      this.parseValue(visitor.visitParameter(null));
    }
    token=this.tokens.next();
switch (token.type()) {
case BaseSymbols.CLOSE_PARENTHESIS:
      visitor.visitEnd();
    return;
case BaseSymbols.COMMA:
case BaseSymbols.SEMICOLON:
  token=token.next();
}
}
}
Program: 82949
Project: 82949
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str"));
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType prevType=this.value.getType();
  IValue value1=this.value.withType(this.type,this.type,markers,context);
  if (value1 != null) {
    this.value=value1;
    IType valueType=value1.getType();
    if (!prevType.isSameType(valueType) && this.type.isSuperClassOf(valueType) && valueType.isPrimitive() == this.type.isPrimitive()) {
      this.typeHint=true;
      this.type=valueType;
      return this;
    }
    prevType=valueType;
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (value1 == null && !(primitiveType && primitiveValue) && !prevType.isSuperClassOf(this.type)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",prevType,this.type));
    return this;
  }
  if (!this.typeHint && this.type.isSameType(prevType) && primitiveType == primitiveValue) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str"));
    this.typeHint=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  if (this.value == null) {
    return this;
  }
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str"));
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType valueType=this.value.getType();
  final IValue typedValue=this.value.withType(this.type,this.type,markers,context);
  if (typedValue != null) {
    this.value=typedValue;
    final IType newType=typedValue.getType();
    if (!valueType.isSameType(newType) && this.type.isSuperClassOf(newType) && newType.isPrimitive() == this.type.isPrimitive()) {
      this.typeHint=true;
      this.type=newType;
      return this;
    }
    valueType=newType;
  }
  final boolean primitiveType=this.type.isPrimitive();
  final boolean primitiveValue=this.value.isPrimitive();
  if (typedValue == null && !(primitiveType && primitiveValue) && !valueType.isSuperClassOf(this.type)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",valueType,this.type));
    return this;
  }
  if (!this.typeHint && this.type.isSameType(valueType) && primitiveType == primitiveValue) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str"));
    this.typeHint=true;
  }
  return this;
}
Program: 82950
Project: 82950
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  this.value.check(markers,context);
}

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

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.TYPE);
  if (this.value != null) {
    this.value.checkTypes(markers,context);
  }
}
Program: 82952
Project: 82952
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolveType(markers,context);
  this.value.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type=this.type.resolveType(markers,context);
  }
 else {
    this.type=Types.UNKNOWN;
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
 else {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
}
Program: 82953
Project: 82953
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.value=this.value.resolve(markers,context);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.resolve(markers,context);
  }
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
  }
  return this;
}
Program: 82954
Project: 82954
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  this.value.check(markers,context);
  if (this.type.isPrimitive()) {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
    return;
  }
  if (this.value.isPrimitive()) {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
    return;
  }
  IType valueType=this.value.getType();
  if (valueType.classEquals(this.type)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",valueType));
    return;
  }
  if (this.type.isSuperClassOf(valueType)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",valueType,this.type));
    return;
  }
  if (!valueType.isSuperClassOf(this.type)) {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str",valueType,this.type));
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.check(markers,context);
    if (this.type.isPrimitive()) {
      markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
      return;
    }
  }
 else {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
    return;
  }
  if (this.value != null) {
    this.value.check(markers,context);
  }
 else {
    return;
  }
  if (this.value.isPrimitive()) {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
    return;
  }
  final IType valueType=this.value.getType();
  if (valueType.classEquals(this.type)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",valueType));
    return;
  }
  if (this.type.isSuperClassOf(valueType)) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str",valueType,this.type));
    return;
  }
  if (!valueType.isSuperClassOf(this.type)) {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str",valueType,this.type));
  }
}
Program: 82955
Project: 82955
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.CLASS);
  this.value.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type.checkType(markers,context,TypePosition.CLASS);
  }
  if (this.value != null) {
    this.value.checkTypes(markers,context);
  }
}
Program: 82956
Project: 82956
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolveType(markers,context);
  this.value.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.type != null) {
    this.type=this.type.resolveType(markers,context);
  }
 else {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
 else {
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
}
Program: 82957
Project: 82957
Buggy source:
@Override public void setPosition(ICodePosition position){
}

Fixed version (ground truth):
@Override public void setPosition(ICodePosition position){
  this.position=position;
}
Program: 82958
Project: 82958
Buggy source:
@Override public ICodePosition getPosition(){
  return null;
}

Fixed version (ground truth):
@Override public ICodePosition getPosition(){
  return this.position;
}
Program: 82959
Project: 82959
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  IContext combinedContext=new CombiningContext(this,context);
  this.type=this.type.resolveType(markers,combinedContext);
  for (int i=0; i < this.typeVariableCount; i++) {
    this.typeVariables[i].resolveTypes(markers,combinedContext);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  IContext combinedContext=new CombiningContext(this,context);
  if (this.type == null) {
    this.type=Types.UNKNOWN;
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
  this.type=this.type.resolveType(markers,combinedContext);
  for (int i=0; i < this.typeVariableCount; i++) {
    this.typeVariables[i].resolveTypes(markers,combinedContext);
  }
}
Program: 82960
Project: 82960
Buggy source:
@Override public void parse(IParserManager pm,IToken token){
  int type=token.type();
switch (this.mode) {
case END:
    this.map.addTypeAlias(this.typeAlias);
  pm.popParser(true);
return;
case TYPE:
this.mode=NAME;
if (type != DyvilKeywords.TYPE) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
case NAME:
if (ParserUtil.isIdentifier(type)) {
Name name=token.nameValue();
this.typeAlias=new TypeAlias(name);
this.mode=TYPE_PARAMETERS;
return;
}
pm.popParser();
pm.report(token,"String_Node_Str");
return;
case TYPE_PARAMETERS:
if (type == BaseSymbols.OPEN_SQUARE_BRACKET) {
this.typeAlias.setTypeParameterized();
this.mode=TYPE_PARAMETERS_END;
pm.pushParser(new TypeParameterListParser(this.typeAlias));
return;
}
case EQUAL:
this.mode=END;
pm.pushParser(pm.newTypeParser(this.typeAlias));
if (type != BaseSymbols.EQUALS) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
case TYPE_PARAMETERS_END:
this.mode=EQUAL;
if (type != BaseSymbols.CLOSE_SQUARE_BRACKET) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
}
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token){
  int type=token.type();
switch (this.mode) {
case END:
    this.map.addTypeAlias(this.typeAlias);
  pm.popParser(true);
return;
case TYPE:
this.mode=NAME;
if (type != DyvilKeywords.TYPE) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
case NAME:
if (ParserUtil.isIdentifier(type)) {
Name name=token.nameValue();
this.typeAlias=new TypeAlias(name,token.raw());
this.mode=TYPE_PARAMETERS;
return;
}
pm.popParser();
pm.report(token,"String_Node_Str");
return;
case TYPE_PARAMETERS:
if (type == BaseSymbols.OPEN_SQUARE_BRACKET) {
this.typeAlias.setTypeParameterized();
this.mode=TYPE_PARAMETERS_END;
pm.pushParser(new TypeParameterListParser(this.typeAlias));
return;
}
case EQUAL:
this.mode=END;
pm.pushParser(pm.newTypeParser(this.typeAlias));
if (type != BaseSymbols.EQUALS) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
case TYPE_PARAMETERS_END:
this.mode=EQUAL;
if (type != BaseSymbols.CLOSE_SQUARE_BRACKET) {
pm.reparse();
pm.report(token,"String_Node_Str");
}
return;
}
}
Program: 82962
Project: 82962
Buggy source:
@Override public boolean hasTypeVariables(){
  return this.bound == null ? false : this.bound.hasTypeVariables();
}

Fixed version (ground truth):
@Override public boolean hasTypeVariables(){
  return this.bound != null && this.bound.hasTypeVariables();
}
Program: 82964
Project: 82964
Buggy source:
@Override public void visitParameter(String name,int modifiers){
  final IParameter parameter=this.method.getParameter_(this.parameterIndex++);
  parameter.setName(Name.getQualified(name));
  if (modifiers != 0) {
    parameter.getModifiers().addIntModifier(modifiers);
  }
}

Fixed version (ground truth):
@Override public void visitParameter(String name,int modifiers){
  final IParameter parameter=this.method.getParameter_(this.parameterIndex);
  if (parameter == null) {
    return;
  }
  this.parameterIndex++;
  parameter.setName(Name.getQualified(name));
  if (modifiers != 0) {
    parameter.getModifiers().addIntModifier(modifiers);
  }
}
Program: 82965
Project: 82965
Buggy source:
@Override public void writeExpression(MethodWriter writer,IType type) throws BytecodeException {
  final IType fieldType=this.field.getType();
  final int lineNumber=this.getLineNumber();
  if (this.receiver == null) {
    this.value.writeExpression(writer,fieldType);
    if (type != Types.VOID) {
      writer.writeInsn(Opcodes.AUTO_DUP);
    }
  }
 else {
    this.receiver.writeExpression(writer,null);
    this.value.writeExpression(writer,fieldType);
    if (type != Types.VOID) {
      writer.writeInsn(Opcodes.AUTO_DUP_X1);
    }
  }
  this.field.writeSet(writer,null,null,lineNumber);
  if (type != null && type != Types.VOID) {
    fieldType.writeCast(writer,type,lineNumber);
  }
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer,IType type) throws BytecodeException {
  final int lineNumber=this.getLineNumber();
  if (type == Types.VOID) {
    this.field.writeSet(writer,this.receiver,this.value,lineNumber);
    return;
  }
  if (type == null) {
    type=this.getType();
  }
  final IType fieldType=this.field.getType();
  if (this.receiver != null) {
    this.receiver.writeExpression(writer,null);
  }
  this.field.writeSet_PreValue(writer,lineNumber);
  if (this.receiver == null) {
    final boolean tempVar=this.field.writeSet_PreValue(writer,lineNumber);
    this.value.writeExpression(writer,fieldType);
    writer.writeInsn(tempVar ? Opcodes.AUTO_DUP_X1 : Opcodes.AUTO_DUP);
  }
 else {
    this.field.writeSet_PreValue(writer,lineNumber);
    this.value.writeExpression(writer,fieldType);
    writer.writeInsn(Opcodes.AUTO_DUP_X1);
  }
  this.field.writeSet_Wrap(writer,lineNumber);
  this.field.writeSet_Set(writer,lineNumber);
  fieldType.writeCast(writer,type,lineNumber);
}
Program: 82966
Project: 82966
Buggy source:
default void writeGet(MethodWriter writer,IValue receiver,int lineNumber) throws BytecodeException {
  this.writeGet_PreReceiver(writer,lineNumber);
  if (receiver != null) {
    receiver.writeExpression(writer,this.getTheClass().getType());
  }
  this.writeGet_Get(writer,lineNumber);
  this.writeGet_Unwrap(writer,lineNumber);
}

Fixed version (ground truth):
default void writeGet(MethodWriter writer,IValue receiver,int lineNumber) throws BytecodeException {
  if (receiver != null) {
    receiver.writeExpression(writer,this.getTheClass().getType());
  }
  this.writeGet_Get(writer,lineNumber);
  this.writeGet_Unwrap(writer,lineNumber);
}
Program: 82967
Project: 82967
Buggy source:
default void writeSet(MethodWriter writer,IValue receiver,IValue value,int lineNumber) throws BytecodeException {
  this.writeSet_PreReceiver(writer,lineNumber);
  if (receiver != null) {
    receiver.writeExpression(writer,this.getTheClass().getType());
  }
  this.writeSet_PreValue(writer,lineNumber);
  value.writeExpression(writer,this.getType());
  this.writeSet_Wrap(writer,lineNumber);
  this.writeSet_Set(writer,lineNumber);
}

Fixed version (ground truth):
default void writeSet(MethodWriter writer,IValue receiver,IValue value,int lineNumber) throws BytecodeException {
  if (receiver != null) {
    receiver.writeExpression(writer,this.getTheClass().getType());
  }
  this.writeSet_PreValue(writer,lineNumber);
  value.writeExpression(writer,this.getType());
  this.writeSet_Wrap(writer,lineNumber);
  this.writeSet_Set(writer,lineNumber);
}
Program: 82969
Project: 82969
Buggy source:
@Override public void writeSet_Wrap(MethodWriter writer,int lineNumber) throws BytecodeException {
  if (this.refType != null) {
    this.refType.writeWrap(writer,this.localIndex);
  }
}

Fixed version (ground truth):
@Override public void writeSet_Wrap(MethodWriter writer,int lineNumber) throws BytecodeException {
  if (this.refType != null) {
    this.refType.writeWrap(writer);
  }
}
Program: 82970
Project: 82970
Buggy source:
@Override public void writeGet_Unwrap(MethodWriter writer,int lineNumber) throws BytecodeException {
  if (this.refType != null) {
    this.refType.writeUnwrap(writer,this.localIndex);
  }
}

Fixed version (ground truth):
@Override public void writeGet_Unwrap(MethodWriter writer,int lineNumber) throws BytecodeException {
  if (this.refType != null) {
    this.refType.writeUnwrap(writer);
  }
}
Program: 82971
Project: 82971
Buggy source:
public void writeUnwrap(MethodWriter writer,int index) throws BytecodeException {
  String internal=this.theClass.getInternalName();
  if (this.theClass == Types.getObjectRefClass()) {
    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str","String_Node_Str",true);
    if (this.type.getTheClass() != Types.OBJECT_CLASS) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
    return;
  }
  StringBuilder sb=new StringBuilder("String_Node_Str");
  this.type.appendExtendedName(sb);
  writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str",sb.toString(),true);
}

Fixed version (ground truth):
public void writeUnwrap(MethodWriter writer) throws BytecodeException {
  final String internal=this.theClass.getInternalName();
  if (this.theClass == Types.getObjectRefClass()) {
    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str","String_Node_Str",true);
    if (this.type.getTheClass() != Types.OBJECT_CLASS) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
    return;
  }
  final StringBuilder stringBuilder=new StringBuilder("String_Node_Str");
  this.type.appendExtendedName(stringBuilder);
  writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str",stringBuilder.toString(),true);
}
Program: 82972
Project: 82972
Buggy source:
public void writeWrap(MethodWriter writer,int index) throws BytecodeException {
  String internal=this.theClass.getInternalName();
  if (this.theClass == Types.getObjectRefClass()) {
    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str","String_Node_Str",true);
    return;
  }
  StringBuilder sb=new StringBuilder().append('(');
  this.type.appendExtendedName(sb);
  sb.append("String_Node_Str");
  writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str",sb.toString(),true);
}

Fixed version (ground truth):
public void writeWrap(MethodWriter writer) throws BytecodeException {
  final String internal=this.theClass.getInternalName();
  if (this.theClass == Types.getObjectRefClass()) {
    writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str","String_Node_Str",true);
    return;
  }
  final StringBuilder stringBuilder=new StringBuilder().append('(');
  this.type.appendExtendedName(stringBuilder);
  stringBuilder.append("String_Node_Str");
  writer.writeInvokeInsn(Opcodes.INVOKEINTERFACE,internal,"String_Node_Str",stringBuilder.toString(),true);
}
Program: 82973
Project: 82973
Buggy source:
@Override public AnnotationVisitor visitTypeAnnotation(int typeRef,TypePath typePath,String desc,boolean visible){
  IAnnotation annotation=new Annotation(ClassFormat.extendedToType(desc));
switch (TypeReference.getSort(typeRef)) {
case TypeReference.METHOD_RETURN:
    this.type=IType.withAnnotation(this.type,annotation,typePath,0,typePath.getLength());
  break;
case TypeReference.METHOD_TYPE_PARAMETER:
{
  ITypeVariable typeVar=this.generics[TypeReference.getTypeParameterIndex(typeRef)];
  if (typeVar.addRawAnnotation(desc,annotation)) {
    return null;
  }
  typeVar.addAnnotation(annotation);
  break;
}
case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
{
ITypeVariable typeVar=this.generics[TypeReference.getTypeParameterIndex(typeRef)];
typeVar.addBoundAnnotation(annotation,TypeReference.getTypeParameterBoundIndex(typeRef),typePath);
break;
}
case TypeReference.EXCEPTION_PARAMETER:
{
int index=TypeReference.getExceptionIndex(typeRef);
this.exceptions[index]=IType.withAnnotation(this.exceptions[index],annotation,typePath,0,typePath.getLength());
break;
}
case TypeReference.METHOD_FORMAL_PARAMETER:
{
int index=TypeReference.getFormalParameterIndex(typeRef);
IParameter param=this.parameters[index];
param.setType(IType.withAnnotation(param.getType(),annotation,typePath,0,typePath.getLength()));
break;
}
}
return new AnnotationReader(null,annotation);
}

Fixed version (ground truth):
@Override public AnnotationVisitor visitTypeAnnotation(int typeRef,TypePath typePath,String desc,boolean visible){
  IAnnotation annotation=new Annotation(ClassFormat.extendedToType(desc));
  if (typePath == null) {
    typePath=TypePath.EMPTY;
  }
switch (TypeReference.getSort(typeRef)) {
case TypeReference.METHOD_RETURN:
    this.type=IType.withAnnotation(this.type,annotation,typePath,0,typePath.getLength());
  break;
case TypeReference.METHOD_TYPE_PARAMETER:
{
  ITypeVariable typeVar=this.generics[TypeReference.getTypeParameterIndex(typeRef)];
  if (typeVar.addRawAnnotation(desc,annotation)) {
    return null;
  }
  typeVar.addAnnotation(annotation);
  break;
}
case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
{
ITypeVariable typeVar=this.generics[TypeReference.getTypeParameterIndex(typeRef)];
typeVar.addBoundAnnotation(annotation,TypeReference.getTypeParameterBoundIndex(typeRef),typePath);
break;
}
case TypeReference.EXCEPTION_PARAMETER:
{
int index=TypeReference.getExceptionIndex(typeRef);
this.exceptions[index]=IType.withAnnotation(this.exceptions[index],annotation,typePath,0,typePath.getLength());
break;
}
case TypeReference.METHOD_FORMAL_PARAMETER:
{
int index=TypeReference.getFormalParameterIndex(typeRef);
IParameter param=this.parameters[index];
param.setType(IType.withAnnotation(param.getType(),annotation,typePath,0,typePath.getLength()));
break;
}
}
return new AnnotationReader(null,annotation);
}
Program: 82974
Project: 82974
Buggy source:
@Override public void checkType(MarkerList markers,IContext context,TypePosition position){
  if (position == TypePosition.CLASS) {
    markers.add(MarkerMessages.createMarker(this.returnType.getPosition(),"String_Node_Str"));
  }
  for (int i=0; i < this.parameterCount; i++) {
    this.parameterTypes[i].checkType(markers,context,TypePosition.PARAMETER_TYPE);
  }
  this.returnType.checkType(markers,context,TypePosition.RETURN_TYPE);
}

Fixed version (ground truth):
@Override public void checkType(MarkerList markers,IContext context,TypePosition position){
  if (position == TypePosition.CLASS) {
    markers.add(MarkerMessages.createMarker(this.position,"String_Node_Str"));
  }
  for (int i=0; i < this.parameterCount; i++) {
    this.parameterTypes[i].checkType(markers,context,TypePosition.PARAMETER_TYPE);
  }
  this.returnType.checkType(markers,context,TypePosition.RETURN_TYPE);
}
Program: 82975
Project: 82975
Buggy source:
@Override public IType resolveType(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    this.parameterTypes[i]=this.parameterTypes[i].resolveType(markers,context).getParameterType();
  }
  if (this.returnType == null) {
    this.returnType=Types.UNKNOWN;
    markers.add(MarkerMessages.createError(this.getPosition(),"String_Node_Str"));
  }
  this.returnType=this.returnType.resolveType(markers,context).getReturnType();
  return this;
}

Fixed version (ground truth):
@Override public IType resolveType(MarkerList markers,IContext context){
  for (int i=0; i < this.parameterCount; i++) {
    this.parameterTypes[i]=this.parameterTypes[i].resolveType(markers,context).getParameterType();
  }
  if (this.returnType == null) {
    this.returnType=Types.UNKNOWN;
    markers.add(MarkerMessages.createError(this.position,"String_Node_Str"));
  }
 else {
    this.returnType=this.returnType.resolveType(markers,context).getReturnType();
  }
  return this;
}
Program: 82977
Project: 82977
Buggy source:
@Override public void addParameter(IParameter param){
  param.setTheClass(this);
  if (this.parameters == null) {
    this.parameters=new ClassParameter[2];
    this.parameters[0]=param;
    this.parameterCount=1;
    return;
  }
  int index=this.parameterCount++;
  if (this.parameterCount > this.parameters.length) {
    IParameter[] temp=new IParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
  param.setIndex(index);
}

Fixed version (ground truth):
@Override public void addParameter(IParameter param){
  param.setTheClass(this);
  if (this.parameters == null) {
    param.setIndex(0);
    this.parameters=new ClassParameter[2];
    this.parameters[0]=param;
    this.parameterCount=1;
    return;
  }
  final int index=this.parameterCount++;
  param.setIndex(index);
  if (this.parameterCount > this.parameters.length) {
    IParameter[] temp=new IParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
}
Program: 82978
Project: 82978
Buggy source:
@Override public void setParameter(int index,IParameter param){
  param.setTheClass(this);
  this.parameters[index]=param;
}

Fixed version (ground truth):
@Override public void setParameter(int index,IParameter param){
  param.setTheClass(this);
  param.setIndex(index);
  this.parameters[index]=param;
}
Program: 82979
Project: 82979
Buggy source:
private void resolveParameters(){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  this.parametersResolved=true;
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(null,this);
  }
}

Fixed version (ground truth):
private void resolveParameters(){
  if (!this.genericsResolved) {
    this.resolveGenerics();
  }
  this.parametersResolved=true;
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].resolveTypes(null,this);
  }
}
Program: 82980
Project: 82980
Buggy source:
@Override public void addParameter(IParameter param){
  param.setMethod(this);
  int index=this.parameterCount++;
  if (index >= this.parameters.length) {
    MethodParameter[] temp=new MethodParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
}

Fixed version (ground truth):
@Override public void addParameter(IParameter param){
  final int index=this.parameterCount++;
  param.setMethod(this);
  param.setIndex(index);
  if (index >= this.parameters.length) {
    MethodParameter[] temp=new MethodParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
}
Program: 82981
Project: 82981
Buggy source:
@Override public void setParameter(int index,IParameter param){
  param.setMethod(this);
  this.parameters[index]=param;
}

Fixed version (ground truth):
@Override public void setParameter(int index,IParameter param){
  param.setMethod(this);
  param.setIndex(index);
  this.parameters[index]=param;
}
Program: 82982
Project: 82982
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,this);
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,this);
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    param.resolveTypes(markers,this);
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolveType(markers,this);
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS)) {
    this.modifiers.addIntModifier(Modifiers.ABSTRACT | Modifiers.PUBLIC);
  }
 else   if (this.theClass.hasModifier(Modifiers.ABSTRACT)) {
    this.modifiers.addIntModifier(Modifiers.ABSTRACT);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,this);
  for (int i=0; i < this.genericCount; i++) {
    this.generics[i].resolveTypes(markers,this);
  }
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].resolveTypes(markers,this);
  }
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i]=this.exceptions[i].resolveType(markers,this);
  }
  if (this.value != null) {
    this.value.resolveTypes(markers,this);
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS)) {
    this.modifiers.addIntModifier(Modifiers.ABSTRACT | Modifiers.PUBLIC);
  }
 else   if (this.theClass.hasModifier(Modifiers.ABSTRACT)) {
    this.modifiers.addIntModifier(Modifiers.ABSTRACT);
  }
}
Program: 82983
Project: 82983
Buggy source:
@Override public void addParameter(IParameter param){
  param.setMethod(this);
  int index=this.parameterCount++;
  if (index >= this.parameters.length) {
    IParameter[] temp=new IParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
}

Fixed version (ground truth):
@Override public void addParameter(IParameter param){
  param.setMethod(this);
  final int index=this.parameterCount++;
  param.setIndex(index);
  if (index >= this.parameters.length) {
    IParameter[] temp=new IParameter[this.parameterCount];
    System.arraycopy(this.parameters,0,temp,0,index);
    this.parameters=temp;
  }
  this.parameters[index]=param;
}
Program: 82984
Project: 82984
Buggy source:
@Override public void setParameter(int index,IParameter param){
  param.setMethod(this);
  this.parameters[index]=param;
}

Fixed version (ground truth):
@Override public void setParameter(int index,IParameter param){
  param.setMethod(this);
  param.setIndex(index);
  this.parameters[index]=param;
}
Program: 82985
Project: 82985
Buggy source:
protected void writeAnnotations(MethodWriter writer){
  if (this.annotations != null) {
    AnnotatableVisitor visitor=(desc,visible) -> writer.visitParameterAnnotation(Parameter.this.index,desc,visible);
    int count=this.annotations.annotationCount();
    for (int i=0; i < count; i++) {
      this.annotations.getAnnotation(i).write(visitor);
    }
  }
  this.type.writeAnnotations(writer,TypeReference.newFormalParameterReference(this.index),"String_Node_Str");
  if (this.defaultValue != null) {
    this.writeDefaultAnnotation(writer);
  }
}

Fixed version (ground truth):
protected void writeAnnotations(MethodWriter writer){
  final AnnotatableVisitor visitor=(desc,visible) -> writer.visitParameterAnnotation(Parameter.this.index,desc,visible);
  if (this.annotations != null) {
    final int count=this.annotations.annotationCount();
    for (int i=0; i < count; i++) {
      this.annotations.getAnnotation(i).write(visitor);
    }
  }
  AnnotationUtils.writeModifiers(visitor,this.modifiers);
  this.type.writeAnnotations(writer,TypeReference.newFormalParameterReference(this.index),"String_Node_Str");
  if (this.defaultValue != null) {
    this.writeDefaultAnnotation(writer);
  }
}
Program: 82986
Project: 82986
Buggy source:
@Override public boolean isType(IType type){
  if (type == Types.VOID) {
    return true;
  }
  if (this.then != null && !this.then.isType(type)) {
    return false;
  }
  return !(this.elseThen != null && !this.elseThen.isType(type));
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (type == Types.VOID) {
    return true;
  }
  if (this.then != null && !this.then.isType(type)) {
    return false;
  }
  return this.elseThen == null || this.elseThen.isType(type);
}
Program: 82988
Project: 82988
Buggy source:
private static synchronized void loop(){
  System.out.print("String_Node_Str");
  try {
    String currentCode=readLine();
    if (currentCode == null) {
      return;
    }
    String trim=currentCode.trim();
    if (trim.length() > 1 && trim.charAt(0) == ':' && trim.charAt(1) != ':') {
      runCommand(trim);
      return;
    }
    instance.evaluate(currentCode);
    Thread.sleep(4L);
  }
 catch (  Throwable t) {
    t.printStackTrace();
  }
}

Fixed version (ground truth):
private static synchronized void loop(){
  System.out.print("String_Node_Str");
  String currentCode;
  try {
    currentCode=readLine();
    if (currentCode == null) {
      return;
    }
  }
 catch (  IOException ignored) {
    return;
  }
  try {
    String trim=currentCode.trim();
    if (trim.length() > 1 && trim.charAt(0) == ':' && trim.charAt(1) != ':') {
      runCommand(trim);
      return;
    }
    instance.evaluate(currentCode);
    Thread.sleep(4L);
  }
 catch (  Throwable t) {
    t.printStackTrace();
  }
}
Program: 82989
Project: 82989
Buggy source:
@Override public boolean isSuperClassOf(IType type){
  return this.typeVar == type.getTypeVariable();
}

Fixed version (ground truth):
@Override public boolean isSuperClassOf(IType type){
  return this.typeVar.isSuperClassOf(type);
}
Program: 82990
Project: 82990
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType prevType=this.value.getType();
  IValue value1=this.value.withType(this.type,this.type,markers,context);
  if (value1 != null) {
    this.value=value1;
    IType valueType=value1.getType();
    if (!prevType.isSameType(valueType) && this.type.isSuperClassOf(valueType) && valueType.isPrimitive() == this.type.isPrimitive()) {
      this.typeHint=true;
      this.type=valueType;
      return this;
    }
    prevType=valueType;
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (value1 == null && !(primitiveType && primitiveValue) && !prevType.isSuperClassOf(this.type)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",prevType,this.type));
    return this;
  }
  if (!this.typeHint && this.type.isSuperClassOf(prevType) && primitiveType == primitiveValue) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    this.typeHint=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  IType prevType=this.value.getType();
  IValue value1=this.value.withType(this.type,this.type,markers,context);
  if (value1 != null) {
    this.value=value1;
    IType valueType=value1.getType();
    if (!prevType.isSameType(valueType) && this.type.isSuperClassOf(valueType) && valueType.isPrimitive() == this.type.isPrimitive()) {
      this.typeHint=true;
      this.type=valueType;
      return this;
    }
    prevType=valueType;
  }
  boolean primitiveType=this.type.isPrimitive();
  boolean primitiveValue=this.value.isPrimitive();
  if (value1 == null && !(primitiveType && primitiveValue) && !prevType.isSuperClassOf(this.type)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",prevType,this.type));
    return this;
  }
  if (!this.typeHint && this.type.isSameType(prevType) && primitiveType == primitiveValue) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    this.typeHint=true;
  }
  return this;
}
Program: 82991
Project: 82991
Buggy source:
@Override public void writeCast(MethodWriter writer,IType target,int lineNumber) throws BytecodeException {
  if (!target.isPrimitive()) {
    this.boxMethod.writeInvoke(writer,null,EmptyArguments.INSTANCE,lineNumber);
    return;
  }
switch (this.typecode) {
case BOOLEAN_CODE:
case BYTE_CODE:
case SHORT_CODE:
case CHAR_CODE:
case INT_CODE:
    writeIntCast(target,writer);
  return;
case LONG_CODE:
writeLongCast(target,writer);
return;
case FLOAT_CODE:
writeFloatCast(target,writer);
return;
case DOUBLE_CODE:
writeDoubleCast(target,writer);
return;
}
}

Fixed version (ground truth):
@Override public void writeCast(MethodWriter writer,IType target,int lineNumber) throws BytecodeException {
  IType primitiveTarget=target;
  if (!target.isPrimitive()) {
    primitiveTarget=getPrimitiveType(target);
  }
switch (this.typecode) {
case BOOLEAN_CODE:
case BYTE_CODE:
case SHORT_CODE:
case CHAR_CODE:
case INT_CODE:
    writeIntCast(primitiveTarget,writer);
  break;
case LONG_CODE:
writeLongCast(primitiveTarget,writer);
break;
case FLOAT_CODE:
writeFloatCast(primitiveTarget,writer);
break;
case DOUBLE_CODE:
writeDoubleCast(primitiveTarget,writer);
break;
}
if (primitiveTarget != target) {
primitiveTarget.getBoxMethod().writeInvoke(writer,null,EmptyArguments.INSTANCE,lineNumber);
}
}
Program: 82992
Project: 82992
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if (this.receiver != null) {
    this.receiver.check(markers,context);
  }
  if (this.method != null) {
    IType receiverType=this.receiver.getType();
    IType methodReturnType=super.getType();
    if (!receiverType.isSuperTypeOf(methodReturnType)) {
      Marker marker=I18n.createMarker(this.position,"String_Node_Str",this.name,this.receiver.toString());
      marker.addInfo(I18n.getString("String_Node_Str",receiverType));
      marker.addInfo(I18n.getString("String_Node_Str",methodReturnType));
      markers.add(marker);
    }
    this.method.checkCall(markers,this.position,context,this.receiver,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if (this.receiver != null) {
    this.receiver.check(markers,context);
  }
  if (this.method != null) {
    if (this.receiver != null) {
      IType receiverType=this.receiver.getType();
      IType methodReturnType=this.method.getType();
      if (!receiverType.isSuperTypeOf(methodReturnType)) {
        Marker marker=I18n.createMarker(this.position,"String_Node_Str",this.name,this.receiver.toString());
        marker.addInfo(I18n.getString("String_Node_Str",receiverType));
        marker.addInfo(I18n.getString("String_Node_Str",methodReturnType));
        markers.add(marker);
      }
    }
    this.method.checkCall(markers,this.position,context,this.receiver,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}
Program: 82993
Project: 82993
Buggy source:
default int getSuperTypeDistance(IType superType){
  return this.getTheClass().getSuperTypeDistance(superType);
}

Fixed version (ground truth):
default int getSuperTypeDistance(IType superType){
  IClass iClass=this.getTheClass();
  return iClass == null ? 0 : iClass.getSuperTypeDistance(superType);
}
Program: 82994
Project: 82994
Buggy source:
@Override public void report(IToken token,String message){
  this.pm.jump(this.firstToken);
  this.pm.pushParser(this.pm.newExpressionParser(this));
  this.reset();
  this.mode=SEPARATOR;
}

Fixed version (ground truth):
@Override public void report(IToken token,String message){
  this.revertExpression(this.pm);
}
Program: 82996
Project: 82996
Buggy source:
@Override public void setType(IType type){
  this.type=type;
}

Fixed version (ground truth):
@Override public void setType(IType type){
  this.type=type;
  this.mode=VARIABLE_NAME;
}
Program: 82997
Project: 82997
Buggy source:
@Override public boolean isSuperTypeOf(IType type){
  if (!type.isArrayType()) {
    return false;
  }
  return this.type.isSuperTypeOf(type.getElementType());
}

Fixed version (ground truth):
@Override public boolean isSuperTypeOf(IType type){
  if (!type.isArrayType()) {
    return false;
  }
  IType elementType=type.getElementType();
  return this.type.isSuperTypeOf(elementType) && this.type.isPrimitive() == elementType.isPrimitive();
}
Program: 82998
Project: 82998
Buggy source:
@Override public boolean classEquals(IType type){
  return type.isArrayType() && this.getElementType().classEquals(type.getElementType());
}

Fixed version (ground truth):
@Override public boolean classEquals(IType type){
  if (!type.isArrayType()) {
    return false;
  }
  IType elementType=type.getElementType();
  return this.type.classEquals(elementType) && this.type.isPrimitive() == elementType.isPrimitive();
}