nus-yam/ex-repair huggingface dataset:
Program: 84268
Project: 84268
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: 84269
Project: 84269
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: 84270
Project: 84270
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: 84271
Project: 84271
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: 84272
Project: 84272
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: 84273
Project: 84273
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: 84274
Project: 84274
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: 84276
Project: 84276
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: 84277
Project: 84277
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: 84278
Project: 84278
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: 84279
Project: 84279
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: 84280
Project: 84280
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: 84281
Project: 84281
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: 84282
Project: 84282
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: 84283
Project: 84283
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: 84284
Project: 84284
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: 84285
Project: 84285
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: 84287
Project: 84287
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: 84288
Project: 84288
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: 84289
Project: 84289
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: 84290
Project: 84290
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: 84291
Project: 84291
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: 84292
Project: 84292
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: 84293
Project: 84293
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: 84295
Project: 84295
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: 84296
Project: 84296
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: 84297
Project: 84297
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();
}
Program: 84298
Project: 84298
Buggy source:
@Override public boolean isSuperClassOf(IType type){
  return type.isArrayType() && this.getElementType().isSuperClassOf(type.getElementType());
}

Fixed version (ground truth):
@Override public boolean isSuperClassOf(IType type){
  if (!type.isArrayType()) {
    return false;
  }
  IType elementType=type.getElementType();
  return this.type.isSuperClassOf(elementType) && this.type.isPrimitive() == elementType.isPrimitive();
}
Program: 84299
Project: 84299
Buggy source:
public void set(Object type){
  if (type == LONG || type == DOUBLE) {
    Object o=this.stack[this.stackCount - 1];
    if (o != LONG && o != DOUBLE) {
      this.actualStackCount++;
    }
  }
  this.stack[this.stackCount - 1]=type;
}

Fixed version (ground truth):
public void set(Object type){
  if (type == null) {
    return;
  }
  if (type == LONG || type == DOUBLE) {
    Object o=this.stack[this.stackCount - 1];
    if (o != LONG && o != DOUBLE) {
      this.actualStackCount++;
    }
  }
  this.stack[this.stackCount - 1]=type;
}
Program: 84300
Project: 84300
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.resolveReceiver(markers,context);
  IValue v=this.resolveFieldAccess(markers,context);
  if (v != null) {
    return v;
  }
  Marker marker=I18n.createMarker(this.position,"String_Node_Str",this.name.unqualified);
  marker.addInfo(I18n.getString("String_Node_Str",this.name.qualified));
  if (this.receiver != null) {
    marker.addInfo(I18n.getString("String_Node_Str",this.receiver.getType()));
  }
  markers.add(marker);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.resolveReceiver(markers,context);
  IValue v=this.resolveFieldAccess(markers,context);
  if (v != null) {
    return v;
  }
  if (this.receiver != null && !this.receiver.isResolved()) {
    return this;
  }
  Marker marker=I18n.createMarker(this.position,"String_Node_Str",this.name.unqualified);
  marker.addInfo(I18n.getString("String_Node_Str",this.name.qualified));
  if (this.receiver != null) {
    marker.addInfo(I18n.getString("String_Node_Str",this.receiver.getType()));
  }
  markers.add(marker);
  return this;
}
Program: 84301
Project: 84301
Buggy source:
@Override default IValue resolve(MarkerList markers,IContext context){
  int wildcards=this.wildcardCount();
  if (wildcards > 0) {
    return this.toLambda(markers,context,wildcards);
  }
  this.resolveReceiver(markers,context);
  this.resolveArguments(markers,context);
  IValue resolved=this.resolveCall(markers,context);
  if (resolved != null) {
    return resolved;
  }
  this.reportResolve(markers,context);
  return this;
}

Fixed version (ground truth):
@Override default IValue resolve(MarkerList markers,IContext context){
  int wildcards=this.wildcardCount();
  if (wildcards > 0) {
    return this.toLambda(markers,context,wildcards);
  }
  this.resolveReceiver(markers,context);
  this.resolveArguments(markers,context);
  IValue resolved=this.resolveCall(markers,context);
  if (resolved != null) {
    return resolved;
  }
  IValue receiver=this.getReceiver();
  if (receiver != null && !receiver.isResolved()) {
    return this;
  }
  if (!this.getArguments().isResolved()) {
    return this;
  }
  this.reportResolve(markers,context);
  return this;
}
Program: 84302
Project: 84302
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isArrayType()) {
    return this;
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.NIL_CONVERTIBLE_CLASS);
  if (annotation != null) {
    this.methodName=LiteralConversion.getMethodName(annotation);
    this.requiredType=type;
    return this;
  }
  markers.add(I18n.createMarker(this.position,"String_Node_Str",type));
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (type.isArrayType()) {
    this.requiredType=type;
    this.methodName=Names.apply;
    return this;
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.NIL_CONVERTIBLE_CLASS);
  if (annotation != null) {
    this.methodName=LiteralConversion.getMethodName(annotation);
    this.requiredType=type;
    return this;
  }
  if (type != dyvil.tools.compiler.ast.type.Types.UNKNOWN) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",type));
  }
 else {
    markers.add(I18n.createMarker(this.position,"String_Node_Str",type));
  }
  return this;
}
Program: 84303
Project: 84303
Buggy source:
@Override public void setValue(IValue value){
  REPLVariable field=new REPLVariable(this,ICodePosition.ORIGIN,null,Types.UNKNOWN,value,this.className,Modifiers.FINAL);
  this.memberClass=this.getREPLClass(field);
  value.resolveTypes(this.markers,this);
  value=value.resolve(this.markers,this);
  if (value.valueTag() == IValue.FIELD_ACCESS) {
    IDataMember f=((FieldAccess)value).getField();
    if (f instanceof REPLVariable) {
      ((REPLVariable)f).updateValue();
      System.out.println(f);
      return;
    }
  }
  IType type=value.getType();
  value=value.withType(type,type,this.markers,this);
  if (value == null) {
    throw new Error("String_Node_Str" + type);
  }
  type=value.getType();
  value.checkTypes(this.markers,this);
  value.check(this.markers,this);
  if (this.hasErrors()) {
    return;
  }
  for (int i=0; i < DyvilCompiler.constantFolding; i++) {
    value=value.foldConstants();
  }
  value=value.cleanup(this,this);
  field.setValue(value);
  field.setType(type);
  field.setName(this.getFieldName(type));
  this.compileVariable(field);
  if (type != Types.VOID) {
    this.fields.put(field.getName(),field);
    System.out.println(field.toString());
  }
}

Fixed version (ground truth):
@Override public void setValue(IValue value){
  REPLVariable field=new REPLVariable(this,ICodePosition.ORIGIN,null,Types.UNKNOWN,value,this.className,Modifiers.FINAL);
  this.memberClass=this.getREPLClass(field);
  value.resolveTypes(this.markers,this);
  value=value.resolve(this.markers,this);
  if (value.valueTag() == IValue.FIELD_ACCESS) {
    IDataMember f=((FieldAccess)value).getField();
    if (f instanceof REPLVariable) {
      ((REPLVariable)f).updateValue();
      System.out.println(f);
      return;
    }
  }
  IType type=value.getType();
  IValue typedValue=value.withType(type,type,this.markers,this);
  if (typedValue != null) {
    value=typedValue;
  }
  type=value.getType();
  value.checkTypes(this.markers,this);
  value.check(this.markers,this);
  if (this.hasErrors()) {
    return;
  }
  for (int i=0; i < DyvilCompiler.constantFolding; i++) {
    value=value.foldConstants();
  }
  value=value.cleanup(this,this);
  field.setValue(value);
  field.setType(type);
  field.setName(this.getFieldName(type));
  this.compileVariable(field);
  if (type != Types.VOID) {
    this.fields.put(field.getName(),field);
    System.out.println(field.toString());
  }
}
Program: 84304
Project: 84304
Buggy source:
private IValue typed(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IValue resolved=super.resolve(markers,context);
  this.resolved=true;
  IValue typed;
  if (resolved == this) {
    this.returnType=null;
    typed=super.withType(type,typeContext,markers,context);
  }
 else {
    typed=resolved.withType(type,typeContext,markers,context);
  }
  return typed;
}

Fixed version (ground truth):
private IValue typed(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IValue resolved=super.resolve(markers,context);
  this.resolved=true;
  IValue typed;
  if (resolved == this) {
    this.returnType=null;
    typed=super.withType(type,typeContext,markers,context);
  }
 else {
    typed=resolved.withType(type,typeContext,markers,context);
  }
  if (typed == null) {
    Util.createTypeError(markers,resolved,type,typeContext,"String_Node_Str");
    return resolved;
  }
  return typed;
}
Program: 84305
Project: 84305
Buggy source:
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label start=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label end=new dyvil.tools.asm.Label();
  writer.writeLabel(start);
  int count=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  writer.resetLocals(count);
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables) {
    entry.getValue().writeLocal(writer,start,end);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer) throws BytecodeException {
  dyvil.tools.asm.Label start=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label end=new dyvil.tools.asm.Label();
  writer.writeLabel(start);
  int localCount=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label label=this.labels[i];
      if (label != null) {
        writer.writeLabel(label.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  writer.resetLocals(localCount);
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables) {
    entry.getValue().writeLocal(writer,start,end);
  }
}
Program: 84306
Project: 84306
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.valueCount <= 0) {
    return this;
  }
  IContext context1=new CombiningContext(this,context);
  int len=this.valueCount - 1;
  for (int i=0; i < len; i++) {
    IValue v1=this.values[i];
    IValue v2=v1.resolve(markers,context1);
    if (v1 != v2) {
      this.values[i]=v2;
    }
    if (v2.valueTag() == IValue.VARIABLE) {
      this.addVariable(v2);
    }
    v1=v2.withType(Types.VOID,Types.VOID,markers,context1);
    if (v1 == null) {
      Marker marker=I18n.createMarker(v2.getPosition(),"String_Node_Str");
      marker.addInfo(I18n.getString("String_Node_Str",v2.getType()));
      markers.add(marker);
    }
 else {
      this.values[i]=v1;
    }
  }
  this.values[len]=this.values[len].resolve(markers,context1);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.valueCount <= 0) {
    return this;
  }
  IContext combinedContext=new CombiningContext(this,context);
  int len=this.valueCount - 1;
  for (int i=0; i < len; i++) {
    IValue resolved=this.values[i]=this.values[i].resolve(markers,combinedContext);
    if (resolved.valueTag() == IValue.VARIABLE) {
      this.addVariable(resolved);
    }
    IValue typed=resolved.withType(Types.VOID,Types.VOID,markers,combinedContext);
    if (typed == null) {
      Marker marker=I18n.createMarker(resolved.getPosition(),"String_Node_Str");
      marker.addInfo(I18n.getString("String_Node_Str",resolved.getType()));
      markers.add(marker);
    }
 else {
      this.values[i]=typed;
    }
  }
  this.values[len]=this.values[len].resolve(markers,combinedContext);
  return this;
}
Program: 84307
Project: 84307
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount > 0) {
    IValue v=this.values[this.valueCount - 1].withType(type,typeContext,markers,new CombiningContext(this,context));
    if (v != null) {
      this.values[this.valueCount - 1]=v;
      this.returnType=v.getType();
      return this;
    }
  }
  return type == Types.VOID ? this : null;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount > 0) {
    IValue typed=this.values[this.valueCount - 1].withType(type,typeContext,markers,new CombiningContext(this,context));
    if (typed != null) {
      this.values[this.valueCount - 1]=typed;
      this.returnType=typed.getType();
      return this;
    }
  }
  return type == Types.VOID ? this : null;
}
Program: 84308
Project: 84308
Buggy source:
protected void addVariable(IValue value){
  if (this.variables == null) {
    this.variables=new IdentityHashMap();
  }
  Variable var=((FieldInitializer)value).variable;
  this.variables.put(var.getName(),var);
}

Fixed version (ground truth):
protected void addVariable(IValue value){
  if (this.variables == null) {
    this.variables=new IdentityHashMap<>();
  }
  Variable var=((FieldInitializer)value).variable;
  this.variables.put(var.getName(),var);
}
Program: 84309
Project: 84309
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  int len=this.valueCount - 1;
  if (len < 0) {
    return;
  }
  dyvil.tools.asm.Label start=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label end=new dyvil.tools.asm.Label();
  writer.writeLabel(start);
  int count=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < len; i++) {
      this.values[i].writeStatement(writer);
    }
    this.values[len].writeExpression(writer,this.returnType);
  }
 else {
    for (int i=0; i < len; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
    Label l=this.labels[len];
    if (l != null) {
      writer.writeLabel(l.target);
    }
    this.values[len].writeExpression(writer);
  }
  writer.resetLocals(count);
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables) {
    Variable var=entry.getValue();
    var.writeLocal(writer,start,end);
  }
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  int statementCount=this.valueCount - 1;
  if (statementCount < 0) {
    return;
  }
  dyvil.tools.asm.Label start=new dyvil.tools.asm.Label();
  dyvil.tools.asm.Label end=new dyvil.tools.asm.Label();
  writer.writeLabel(start);
  int localCount=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < statementCount; i++) {
      this.values[i].writeStatement(writer);
    }
    this.values[statementCount].writeExpression(writer,this.returnType);
  }
 else {
    for (int i=0; i < statementCount; i++) {
      Label label=this.labels[i];
      if (label != null) {
        writer.writeLabel(label.target);
      }
      this.values[i].writeStatement(writer);
    }
    Label label=this.labels[statementCount];
    if (label != null) {
      writer.writeLabel(label.target);
    }
    this.values[statementCount].writeExpression(writer);
  }
  writer.resetLocals(localCount);
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables) {
    Variable var=entry.getValue();
    var.writeLocal(writer,start,end);
  }
}
Program: 84310
Project: 84310
Buggy source:
@Override public Iterator<IValue> iterator(){
  return new ArrayIterator(this.values,this.valueCount);
}

Fixed version (ground truth):
@Override public Iterator<IValue> iterator(){
  return new ArrayIterator<>(this.values,this.valueCount);
}
Program: 84311
Project: 84311
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IContext context1=this.variables == null ? context : new CombiningContext(this,context);
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].checkTypes(markers,context1);
  }
}

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

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.valueCount == 0) {
    buffer.append(Formatting.Expression.emptyExpression);
    return;
  }
  buffer.append('\n').append(prefix).append('{').append('\n');
  String indentedPrefix=prefix + Formatting.Method.indent;
  int prevLine=0;
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    ICodePosition pos=value.getPosition();
    buffer.append(indentedPrefix);
    if (pos != null) {
      if (pos.startLine() - prevLine > 1) {
        buffer.append('\n').append(indentedPrefix);
      }
      prevLine=pos.endLine();
    }
    if (this.labels != null) {
      Label l=this.labels[i];
      if (l != null) {
        buffer.append(l.name).append(Formatting.Expression.labelSeperator);
      }
    }
    value.toString(indentedPrefix,buffer);
    buffer.append("String_Node_Str");
  }
  buffer.append(prefix).append('}');
}
Program: 84313
Project: 84313
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
  }
  for (int i=0; i < this.importCount; i++) {
    this.imports[i].resolveTypes(markers,context,using);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
    if (context == null) {
      return;
    }
  }
  for (int i=0; i < this.importCount; i++) {
    this.imports[i].resolveTypes(markers,context,using);
  }
}
Program: 84314
Project: 84314
Buggy source:
@Override public void getMethodMatches(MethodMatchList list,IValue instance,Name name,IArguments arguments){
  this.context.getMethodMatches(list,instance,name,arguments);
}

Fixed version (ground truth):
@Override public void getMethodMatches(MethodMatchList list,IValue instance,Name name,IArguments arguments){
  if (this.context == null) {
    return;
  }
  this.context.getMethodMatches(list,instance,name,arguments);
}
Program: 84315
Project: 84315
Buggy source:
@Override public IClass resolveClass(Name name){
  return this.context.resolveClass(name);
}

Fixed version (ground truth):
@Override public IClass resolveClass(Name name){
  if (this.context == null) {
    return null;
  }
  return this.context.resolveClass(name);
}
Program: 84316
Project: 84316
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
  }
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(I18n.createMarker(this.position,"String_Node_Str"));
      return;
    }
    this.context=context;
    return;
  }
  if (!(context instanceof Package)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return;
  }
  this.context=context;
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context,boolean using){
  if (this.parent != null) {
    this.parent.resolveTypes(markers,context,false);
    context=this.parent.getContext();
    if (context == null) {
      return;
    }
  }
  if (using) {
    if (!(context instanceof IClass)) {
      markers.add(I18n.createMarker(this.position,"String_Node_Str"));
      return;
    }
    this.context=context;
    return;
  }
  if (!(context instanceof Package)) {
    markers.add(I18n.createMarker(this.position,"String_Node_Str"));
    return;
  }
  this.context=context;
}
Program: 84317
Project: 84317
Buggy source:
@Override public Package resolvePackage(Name name){
  return this.context.resolvePackage(name);
}

Fixed version (ground truth):
@Override public Package resolvePackage(Name name){
  if (this.context == null) {
    return null;
  }
  return this.context.resolvePackage(name);
}
Program: 84318
Project: 84318
Buggy source:
@Override public IDataMember resolveField(Name name){
  return this.context.resolveField(name);
}

Fixed version (ground truth):
@Override public IDataMember resolveField(Name name){
  if (this.context == null) {
    return null;
  }
  return this.context.resolveField(name);
}
Program: 84319
Project: 84319
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IMethod method=this.method;
  if (method == null) {
    method=IContext.resolveMethod(type,null,this.methodName,this.arguments);
    if (method == null) {
      StringBuilder builder=new StringBuilder();
      this.arguments.typesToString(builder);
      markers.add(I18n.createMarker(this.literal.getPosition(),"String_Node_Str",this.literal.getType(),type,builder));
      this.type=type;
      return null;
    }
    this.method=method;
  }
  GenericData data=method.getGenericData(null,null,this.arguments);
  method.checkArguments(markers,this.literal.getPosition(),context,null,this.arguments,data);
  this.type=method.getType().getConcreteType(data);
  if (!type.isSuperTypeOf(this.type)) {
    Marker m=I18n.createMarker(this.literal.getPosition(),"String_Node_Str");
    m.addInfo("String_Node_Str" + type.getConcreteType(typeContext));
    m.addInfo("String_Node_Str" + this.type);
    StringBuilder sb=new StringBuilder("String_Node_Str");
    Util.methodSignatureToString(method,sb);
    m.addInfo(sb.toString());
    markers.add(m);
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  IMethod method=this.method;
  if (method == null) {
    method=IContext.resolveMethod(type,null,this.methodName,this.arguments);
    if (method == null) {
      StringBuilder builder=new StringBuilder();
      this.arguments.typesToString(builder);
      markers.add(I18n.createMarker(this.literal.getPosition(),"String_Node_Str",this.literal.getType(),type,builder));
      this.type=type;
      return null;
    }
    this.method=method;
  }
  GenericData data=method.getGenericData(null,null,this.arguments);
  method.checkArguments(markers,this.literal.getPosition(),context,null,this.arguments,data);
  this.type=method.getType().getConcreteType(data);
  IType concrete=type.getConcreteType(typeContext);
  if (!concrete.isSuperTypeOf(this.type)) {
    Marker m=I18n.createMarker(this.literal.getPosition(),"String_Node_Str");
    m.addInfo("String_Node_Str" + concrete);
    m.addInfo("String_Node_Str" + this.type);
    StringBuilder sb=new StringBuilder("String_Node_Str");
    Util.methodSignatureToString(method,sb);
    m.addInfo(sb.toString());
    markers.add(m);
  }
  return this;
}