nus-yam/ex-repair huggingface dataset:
Program: 83521
Project: 83521
Buggy source:
protected void processHeader(){
  MarkerList markers=new MarkerList();
  if (tempClass != null) {
    tempClass.resolveTypes(markers,this);
    tempClass.resolve(markers,this);
    tempClass.checkTypes(markers,this);
    tempClass.check(markers,this);
    tempClass.foldConstants();
    super.addClass(tempClass);
    System.out.println("String_Node_Str" + tempClass.getName());
    tempClass=null;
  }
  if (this.headerComponent == null || this.headerComponent.theImport == null) {
    return;
  }
  headerComponent.resolveTypes(markers,this,false);
  if (this.reportErrors(markers)) {
    return;
  }
  boolean isStatic=headerComponent.isStatic;
  if (isStatic) {
    super.addStaticImport(headerComponent);
    System.out.println("String_Node_Str" + headerComponent.theImport);
  }
 else {
    super.addImport(headerComponent);
    System.out.println("String_Node_Str" + headerComponent.theImport);
  }
  headerComponent=null;
}

Fixed version (ground truth):
protected void processHeader(){
  MarkerList markers=new MarkerList();
  if (tempClass != null) {
    tempClass.resolveTypes(markers,this);
    tempClass.resolve(markers,this);
    tempClass.checkTypes(markers,this);
    tempClass.check(markers,this);
    tempClass.foldConstants();
    super.addClass(tempClass);
    System.out.println("String_Node_Str" + tempClass.getName());
    tempClass=null;
  }
  if (this.includeDeclaration != null) {
    IncludeDeclaration inc=this.includeDeclaration;
    this.includeDeclaration=null;
    inc.resolve(markers);
    if (this.reportErrors(markers)) {
      return;
    }
    this.addIncludeToArray(inc);
    System.out.println("String_Node_Str" + inc.getHeader().getFullName());
    return;
  }
  if (this.importDeclaration == null || this.importDeclaration.theImport == null) {
    return;
  }
  importDeclaration.resolveTypes(markers,this,false);
  if (this.reportErrors(markers)) {
    return;
  }
  boolean isStatic=importDeclaration.isStatic;
  if (isStatic) {
    super.addStaticImport(importDeclaration);
    System.out.println("String_Node_Str" + importDeclaration.theImport);
  }
 else {
    super.addImport(importDeclaration);
    System.out.println("String_Node_Str" + importDeclaration.theImport);
  }
  importDeclaration=null;
}
Program: 83522
Project: 83522
Buggy source:
@Override public void addStaticImport(ImportDeclaration component){
  headerComponent=component;
}

Fixed version (ground truth):
@Override public void addStaticImport(ImportDeclaration component){
  importDeclaration=component;
}
Program: 83523
Project: 83523
Buggy source:
@Override public void addImport(ImportDeclaration component){
  headerComponent=component;
}

Fixed version (ground truth):
@Override public void addImport(ImportDeclaration component){
  importDeclaration=component;
}
Program: 83524
Project: 83524
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 83525
Project: 83525
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 83526
Project: 83526
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 83527
Project: 83527
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.genericData != null) {
    this.genericData.resolveTypes(markers,context);
  }
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.genericData != null) {
    this.genericData.resolveTypes(markers,context);
  }
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 83528
Project: 83528
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  this.arguments.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolveTypes(markers,context);
  }
  if (this.arguments.isEmpty()) {
    this.arguments=EmptyArguments.VISIBLE;
  }
 else {
    this.arguments.resolveTypes(markers,context);
  }
}
Program: 83530
Project: 83530
Buggy source:
private void writeArguments(MethodWriter writer,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    int len=this.parameterCount;
    if ((this.modifiers & Modifiers.VARARGS) != 0) {
      len--;
      IParameter param;
      for (int i=1, j=0; i < len; i++, j++) {
        param=this.parameters[i];
        arguments.writeValue(j,param.getName(),param.getValue(),writer);
      }
      param=this.parameters[len];
      arguments.writeVarargsValue(len - 1,param.getName(),param.getType(),writer);
      return;
    }
    for (int i=1, j=0; i < this.parameterCount; i++, j++) {
      IParameter param=this.parameters[i];
      arguments.writeValue(j,param.getName(),param.getValue(),writer);
    }
    return;
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    arguments.writeValue(0,Name._this,null,writer);
    return;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int len=this.parameterCount - 1;
    IParameter param;
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      arguments.writeValue(i,param.getName(),param.getValue(),writer);
    }
    param=this.parameters[len];
    arguments.writeVarargsValue(len,param.getName(),param.getType(),writer);
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    arguments.writeValue(i,param.getName(),param.getValue(),writer);
  }
}

Fixed version (ground truth):
private void writeArguments(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null && (this.modifiers & Modifiers.INFIX) == Modifiers.INFIX) {
    int len=this.parameterCount;
    if ((this.modifiers & Modifiers.VARARGS) != 0) {
      len--;
      IParameter param;
      for (int i=1, j=0; i < len; i++, j++) {
        param=this.parameters[i];
        arguments.writeValue(j,param.getName(),param.getValue(),writer);
      }
      param=this.parameters[len];
      arguments.writeVarargsValue(len - 1,param.getName(),param.getType(),writer);
      return;
    }
    for (int i=1, j=0; i < this.parameterCount; i++, j++) {
      IParameter param=this.parameters[i];
      arguments.writeValue(j,param.getName(),param.getValue(),writer);
    }
    return;
  }
  if ((this.modifiers & Modifiers.PREFIX) == Modifiers.PREFIX) {
    arguments.writeValue(0,Name._this,null,writer);
    return;
  }
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    int len=this.parameterCount - 1;
    IParameter param;
    for (int i=0; i < len; i++) {
      param=this.parameters[i];
      arguments.writeValue(i,param.getName(),param.getValue(),writer);
    }
    param=this.parameters[len];
    arguments.writeVarargsValue(len,param.getName(),param.getType(),writer);
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    arguments.writeValue(i,param.getName(),param.getValue(),writer);
  }
}
Program: 83531
Project: 83531
Buggy source:
private void writeIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(i,dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}

Fixed version (ground truth):
private void writeIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,instance,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(i,dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}
Program: 83532
Project: 83532
Buggy source:
private void writeInvIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(Opcodes.getInverseOpcode(i),dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}

Fixed version (ground truth):
private void writeInvIntrinsic(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  for (  int i : this.intrinsicOpcodes) {
    if (i == INSTANCE) {
      instance.writeExpression(writer);
    }
 else     if (i == ARGUMENTS) {
      this.writeArguments(writer,instance,arguments);
    }
 else     if (Opcodes.isJumpOpcode(i)) {
      writer.writeJumpInsn(Opcodes.getInverseOpcode(i),dest);
    }
 else {
      writer.writeInsn(i);
    }
  }
}
Program: 83533
Project: 83533
Buggy source:
private void writeInvoke(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
  }
  this.writeArguments(writer,arguments);
  int opcode;
  int modifiers=this.modifiers;
  if ((modifiers & Modifiers.STATIC) != 0) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS) && this.value == null) {
    opcode=Opcodes.INVOKEINTERFACE;
  }
 else   if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else   if (instance != null && instance.valueTag() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.getDescriptor();
  writer.writeInvokeInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS));
}

Fixed version (ground truth):
private void writeInvoke(MethodWriter writer,IValue instance,IArguments arguments) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
  }
  this.writeArguments(writer,instance,arguments);
  int opcode;
  int modifiers=this.modifiers;
  if ((modifiers & Modifiers.STATIC) != 0) {
    opcode=Opcodes.INVOKESTATIC;
  }
 else   if (this.theClass.hasModifier(Modifiers.INTERFACE_CLASS) && this.value == null) {
    opcode=Opcodes.INVOKEINTERFACE;
  }
 else   if ((modifiers & Modifiers.PRIVATE) == Modifiers.PRIVATE) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else   if (instance != null && instance.valueTag() == IValue.SUPER) {
    opcode=Opcodes.INVOKESPECIAL;
  }
 else {
    opcode=Opcodes.INVOKEVIRTUAL;
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.getDescriptor();
  writer.writeInvokeInsn(opcode,owner,name,desc,this.theClass.hasModifier(Modifiers.INTERFACE_CLASS));
}
Program: 83534
Project: 83534
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    this.value.checkTypes(markers,context);
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  if (!this.typeHint && this.type.isSuperTypeOf(this.value.getType())) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  IValue value1=this.value.withType(this.type);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.value.checkTypes(markers,context);
    this.type=value1.getType();
    return this;
  }
  this.value.checkTypes(markers,context);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  if (this.type == Types.VOID) {
    markers.add(this.position,"String_Node_Str");
    this.value.checkTypes(markers,context);
    return this;
  }
  if (!this.type.isResolved()) {
    return this;
  }
  if (!this.typeHint && this.type.equals(this.value.getType())) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  IValue value1=this.value.withType(this.type);
  if (value1 != null && value1 != this.value) {
    this.value=value1;
    this.typeHint=true;
    this.value.checkTypes(markers,context);
    this.type=value1.getType();
    return this;
  }
  this.value.checkTypes(markers,context);
  return this;
}
Program: 83535
Project: 83535
Buggy source:
@Override public HashMap<K,V> copy(){
  int len=MathUtils.powerOfTwo(this.size);
  HashEntry[] newEntries=new HashEntry[len];
  for (  HashEntry<K,V> e : this.entries) {
    while (e != null) {
      int index=index(e.hash,len);
      HashEntry<K,V> newEntry=new HashEntry(e.key,e.value,e.hash);
      if (newEntries[index] != null) {
        newEntry.next=newEntries[index];
      }
      newEntries[index]=newEntry;
      e=e.next;
    }
  }
  return new HashMap<>(this.size,this.loadFactor,newEntries);
}

Fixed version (ground truth):
@Override public HashMap<K,V> copy(){
  int len=MathUtils.powerOfTwo(this.size + 2);
  HashEntry[] newEntries=new HashEntry[len];
  for (  HashEntry<K,V> e : this.entries) {
    while (e != null) {
      int index=index(e.hash,len);
      HashEntry<K,V> newEntry=new HashEntry(e.key,e.value,e.hash);
      if (newEntries[index] != null) {
        newEntry.next=newEntries[index];
      }
      newEntries[index]=newEntry;
      e=e.next;
    }
  }
  return new HashMap<>(this.size,this.loadFactor,newEntries);
}
Program: 83536
Project: 83536
Buggy source:
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  if (this.instanceField != null) {
    this.instanceField.write(writer);
  }
  super.write(writer,instanceFields);
  if (!this.hasToString) {
    MethodWriterImpl mw=new MethodWriterImpl(writer,writer.visitMethod(Modifiers.PUBLIC,"String_Node_Str","String_Node_Str",null,null));
    mw.begin();
    mw.writeLDC(this.theClass.getName().unqualified);
    mw.writeInsn(Opcodes.ARETURN);
    mw.end(Types.STRING);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer,IValue instanceFields) throws BytecodeException {
  if (this.instanceField != null) {
    this.instanceField.write(writer);
  }
  super.write(writer,instanceFields);
  if (!this.hasToString) {
    MethodWriterImpl mw=new MethodWriterImpl(writer,writer.visitMethod(Modifiers.PUBLIC,"String_Node_Str","String_Node_Str",null,null));
    mw.begin();
    mw.setThisType(this.theClass.getInternalName());
    mw.writeLDC(this.theClass.getName().unqualified);
    mw.writeInsn(Opcodes.ARETURN);
    mw.end(Types.STRING);
  }
}
Program: 83538
Project: 83538
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v1=this.values[i].withType(typeList.getType(i));
      if (v1 != null) {
        this.values[i]=v1;
      }
 else {
      }
      this.values[i].checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,this.position,context,null,this.arguments,null);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IType type=typeList.getType(i);
      IValue value=this.values[i];
      IValue value1=value.withType(type);
      if (value1 == null) {
        Marker m=markers.create(value.getPosition(),"String_Node_Str");
        m.addInfo("String_Node_Str" + value.getType());
        m.addInfo("String_Node_Str" + type);
      }
 else {
        this.values[i]=value=value1;
      }
      value.checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,this.position,context,null,this.arguments,null);
  }
}
Program: 83540
Project: 83540
Buggy source:
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  int dims=this.requiredType.getArrayDimensions();
  if (dims > 0) {
    for (int i=0; i < dims; i++) {
      writer.writeLDC(0);
    }
    writer.writeNewArray(this.requiredType,dims);
    return;
  }
  this.method.writeCall(writer,null,EmptyArguments.INSTANCE,this.requiredType);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer) throws BytecodeException {
  if (this.requiredType.isArrayType()) {
    IType elementType=this.requiredType.getElementType();
    if (elementType.isPrimitive()) {
      writer.writeFieldInsn(Opcodes.GETSTATIC,this.requiredType.getTheClass().getInternalName(),"String_Node_Str",this.requiredType.getExtendedName());
      return;
    }
    writer.writeLDC(0);
    int dims=1;
    while (elementType.isArrayType()) {
      elementType=elementType.getElementType();
      dims++;
      writer.writeLDC(0);
    }
    writer.writeNewArray(elementType,dims);
    return;
  }
  this.method.writeCall(writer,null,EmptyArguments.INSTANCE,this.requiredType);
}
Program: 83541
Project: 83541
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.elementType == null) {
    this.getType();
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].checkTypes(markers,context);
    }
  }
  IType type=this.elementType;
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(type);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
    value.checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.elementType == null) {
    if (this.valueCount == 0) {
      markers.add(this.position,"String_Node_Str");
      return;
    }
    this.getType();
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].checkTypes(markers,context);
    }
  }
  IType type=this.elementType;
  for (int i=0; i < this.valueCount; i++) {
    IValue value=this.values[i];
    IValue value1=value.withType(type);
    if (value1 == null) {
      Marker marker=markers.create(value.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + this.requiredType);
      marker.addInfo("String_Node_Str" + value.getType());
    }
 else {
      value=value1;
      this.values[i]=value1;
    }
    value.checkTypes(markers,context);
  }
}
Program: 83542
Project: 83542
Buggy source:
@Override public void writeNewArray(IType type,int dims) throws BytecodeException {
  if (dims == 1) {
    if (type.typeTag() == IType.PRIMITIVE_TYPE) {
      this.writeIntInsn(Opcodes.NEWARRAY,((PrimitiveType)type).typecode);
      return;
    }
    this.writeTypeInsn(Opcodes.ANEWARRAY,type.getInternalName());
    return;
  }
  this.insnCallback();
  String extended=type.getExtendedName();
  this.frame.visitNewArray(extended,dims);
  this.mv.visitMultiANewArrayInsn(extended,dims);
}

Fixed version (ground truth):
@Override public void writeNewArray(IType type,int dims) throws BytecodeException {
  if (dims == 1) {
    if (type.typeTag() == IType.PRIMITIVE_TYPE) {
      this.writeIntInsn(Opcodes.NEWARRAY,((PrimitiveType)type).typecode);
      return;
    }
    this.writeTypeInsn(Opcodes.ANEWARRAY,type.getInternalName());
    return;
  }
  this.insnCallback();
  StringBuilder builder=new StringBuilder();
  for (int i=0; i < dims; i++) {
    builder.append('[');
  }
  type.appendExtendedName(builder);
  String extended=builder.toString();
  this.frame.visitNewArray(extended,dims);
  this.mv.visitMultiANewArrayInsn(extended,dims);
}
Program: 83543
Project: 83543
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a statement. That means that this element is removedfrom the stack.
 * @param writer
 * @throws BytecodeException TODO
 */
public void writeStatement(MethodWriter writer) throws BytecodeException ;

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a statement. That means that this element is removedfrom the stack.
 * @param writer
 * @throws BytecodeException
 */
public void writeStatement(MethodWriter writer) throws BytecodeException ;
Program: 83544
Project: 83544
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a jump expression to the given {@link Label}{@code dest}. By default, this calls  {@link #writeExpression(MethodWriter)} and then writes an{@link Opcodes#IFEQ IFEQ} instruction pointing to {@code dest}. That means the JVM would jump to   {@code dest} if the current value on thestack equals  {@code 0}.
 * @param writer
 * @param dest
 * @throws BytecodeException TODO
 */
public default void writeInvJump(MethodWriter writer,Label dest) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeJumpInsn(Opcodes.IFEQ,dest);
}

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as a jump expression to the given {@link Label}{@code dest}. By default, this calls  {@link #writeExpression(MethodWriter)} and then writes an{@link Opcodes#IFEQ IFEQ} instruction pointing to {@code dest}. That means the JVM would jump to   {@code dest} if the current value on thestack equals  {@code 0}.
 * @param writer
 * @param dest
 * @throws BytecodeException
 */
public default void writeInvJump(MethodWriter writer,Label dest) throws BytecodeException {
  this.writeExpression(writer);
  writer.writeJumpInsn(Opcodes.IFEQ,dest);
}
Program: 83545
Project: 83545
Buggy source:
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as an expression. That means that this element remains asthe first element of the stack.
 * @param visitor
 * @throws BytecodeException TODO
 */
public void writeExpression(MethodWriter writer) throws BytecodeException ;

Fixed version (ground truth):
/** 
 * Writes this   {@link IValue} to the given {@link MethodWriter}{@code writer} as an expression. That means that this element remains asthe first element of the stack.
 * @param visitor
 * @throws BytecodeException
 */
public void writeExpression(MethodWriter writer) throws BytecodeException ;
Program: 83546
Project: 83546
Buggy source:
@Override public NestedClass getInnerClass(int index){
  return null;
}

Fixed version (ground truth):
@Override public IClassCompilable getInnerClass(int index){
  return null;
}
Program: 83547
Project: 83547
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
}
Program: 83548
Project: 83548
Buggy source:
@Override public NestedClass getInnerClass(int index){
  return this.innerClasses[index];
}

Fixed version (ground truth):
@Override public IClassCompilable getInnerClass(int index){
  return this.innerClasses[index];
}
Program: 83550
Project: 83550
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
  int index=this.innerClassCount++;
  if (index >= this.innerClasses.length) {
    NestedClass[] temp=new NestedClass[this.innerClassCount];
    System.arraycopy(this.innerClasses,0,temp,0,this.innerClasses.length);
    this.innerClasses=temp;
  }
  this.innerClasses[index]=iclass;
  iclass.setIndex(index);
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
  int index=this.innerClassCount++;
  if (index >= this.innerClasses.length) {
    IClassCompilable[] temp=new IClassCompilable[this.innerClassCount];
    System.arraycopy(this.innerClasses,0,temp,0,this.innerClasses.length);
    this.innerClasses=temp;
  }
  this.innerClasses[index]=iclass;
  iclass.setInnerIndex(index);
}
Program: 83551
Project: 83551
Buggy source:
public NestedClass getInnerClass(int index);

Fixed version (ground truth):
public IClassCompilable getInnerClass(int index);
Program: 83552
Project: 83552
Buggy source:
public void addInnerClass(NestedClass iclass);

Fixed version (ground truth):
public void addInnerClass(IClassCompilable iclass);
Program: 83553
Project: 83553
Buggy source:
@Override public final IType getReferenceType(){
  Type type=new Type(this.position,this.theClass);
  type.name=this.name;
  return type;
}

Fixed version (ground truth):
@Override public final IType getReferenceType(){
  Type type=new Type(this.position,this.theClass);
  if (this != Types.VOID) {
    type.name=this.name;
  }
  return type;
}
Program: 83555
Project: 83555
Buggy source:
@Override public void addInnerClass(NestedClass iclass){
  this.tempClass=iclass;
}

Fixed version (ground truth):
@Override public void addInnerClass(IClassCompilable iclass){
}
Program: 83556
Project: 83556
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 83557
Project: 83557
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
    int valueTag=this.instance.valueTag();
    if (valueTag == APPLY_METHOD_CALL) {
      ApplyMethodCall call=(ApplyMethodCall)this.instance;
      IValue instance1=call.instance;
      IArguments arguments1=call.arguments.addLastValue(call);
      IType type=instance1.getType();
      IMethod match=IContext.resolveMethod(type,instance1,Name.update,arguments1);
      if (match != null) {
        this.updateMethod=match;
      }
 else {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
      }
    }
 else     if (valueTag == FIELD_ACCESS) {
      FieldAccess fa=(FieldAccess)this.instance;
      if (fa.field != null) {
        fa.field.checkAssign(markers,this.instance.getPosition(),this.instance,this);
      }
    }
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
    int valueTag=this.instance.valueTag();
    if (valueTag == APPLY_METHOD_CALL) {
      ApplyMethodCall call=(ApplyMethodCall)this.instance;
      IValue instance1=call.instance;
      IArguments arguments1=call.arguments.addLastValue(call);
      IType type=instance1.getType();
      IMethod match=IContext.resolveMethod(type,instance1,Name.update,arguments1);
      if (match != null) {
        this.updateMethod=match;
      }
 else {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
      }
    }
 else     if (valueTag == FIELD_ACCESS) {
      FieldAccess fa=(FieldAccess)this.instance;
      if (fa.field != null) {
        fa.field.checkAssign(markers,this.instance.getPosition(),this.instance,this);
      }
    }
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 83558
Project: 83558
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.constructor != null) {
    this.constructor.checkArguments(markers,this.arguments);
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.constructor != null) {
    this.constructor.checkArguments(markers,this.position,context,this.arguments);
  }
  this.arguments.checkTypes(markers,context);
}
Program: 83559
Project: 83559
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance,context);
  }
}
Program: 83560
Project: 83560
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance);
    this.value=this.field.checkAssign(markers,this.position,this.instance,this.value);
  }
  this.value.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.field != null) {
    this.instance=this.field.checkAccess(markers,this.position,this.instance,context);
    this.value=this.field.checkAssign(markers,this.position,this.instance,this.value);
  }
  this.value.checkTypes(markers,context);
}
Program: 83561
Project: 83561
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.instance=this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.checkTypes(markers,context);
}
Program: 83562
Project: 83562
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
  }
  if (this.method != null) {
    this.method.checkArguments(markers,this.position,context,this.instance,this.arguments,this.getGenericData());
  }
  this.arguments.check(markers,context);
}
Program: 83563
Project: 83563
Buggy source:
@Override public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext){
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  return instance;
}
Program: 83564
Project: 83564
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(this.type,null,Name.apply,this.arguments);
  if (match == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
  }
 else {
    this.method=match;
    GenericData data=match.getGenericData(null,null,this.arguments);
    match.checkArguments(markers,null,this.arguments,data);
    this.type=match.getType().getConcreteType(data);
  }
  this.arguments.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IMethod match=IContext.resolveMethod(this.type,null,Name.apply,this.arguments);
  if (match == null) {
    IValue value=this.arguments.getFirstValue();
    StringBuilder builder=new StringBuilder();
    this.arguments.typesToString(builder);
    markers.add(value.getPosition(),"String_Node_Str",value.getType().getName(),this.type.toString(),builder);
  }
 else {
    this.method=match;
    GenericData data=match.getGenericData(null,null,this.arguments);
    match.checkArguments(markers,null,context,null,this.arguments,data);
    this.type=match.getType().getConcreteType(data);
  }
  this.arguments.checkTypes(markers,context);
}
Program: 83565
Project: 83565
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v1=this.values[i].withType(typeList.getType(i));
      if (v1 != null) {
        this.values[i]=v1;
      }
 else {
      }
      this.values[i].checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,null,this.arguments,null);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.tupleType instanceof TupleType) {
    ITypeList typeList=(ITypeList)this.tupleType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v1=this.values[i].withType(typeList.getType(i));
      if (v1 != null) {
        this.values[i]=v1;
      }
 else {
      }
      this.values[i].checkTypes(markers,context);
    }
    return;
  }
  IMethod m=IContext.resolveMethod(this.getType(),null,Name.apply,this.arguments=new ArgumentList(this.values,this.valueCount));
  if (m == null) {
    StringBuilder builder=new StringBuilder();
    if (this.valueCount > 0) {
      this.values[0].getType().toString("String_Node_Str",builder);
      for (int i=1; i < this.valueCount; i++) {
        builder.append("String_Node_Str");
        this.values[i].getType().toString("String_Node_Str",builder);
      }
    }
    markers.add(this.position,"String_Node_Str",builder.toString(),this.tupleType.toString());
  }
 else {
    this.method=m;
    m.checkArguments(markers,this.position,context,null,this.arguments,null);
  }
}
Program: 83566
Project: 83566
Buggy source:
@Override public void checkArguments(MarkerList markers,IArguments arguments){
  if (!this.returnTypeResolved) {
    this.resolveReturnType();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  super.checkArguments(markers,arguments);
}

Fixed version (ground truth):
@Override public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  if (!this.returnTypeResolved) {
    this.resolveReturnType();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  super.checkArguments(markers,position,context,arguments);
}
Program: 83567
Project: 83567
Buggy source:
@Override public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,instance,arguments,typeContext);
}

Fixed version (ground truth):
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,position,context,instance,arguments,typeContext);
}
Program: 83568
Project: 83568
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance == null) {
    markers.add(position,"String_Node_Str",this.name);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance == null) {
    markers.add(position,"String_Node_Str",this.name);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}
Program: 83569
Project: 83569
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  return this.variable.checkAccess(markers,position,instance);
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  return this.variable.checkAccess(markers,position,instance,context);
}
Program: 83570
Project: 83570
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (context.isStatic()) {
      markers.add(position,"String_Node_Str",this.name);
    }
 else {
      markers.add(position,"String_Node_Str",this.name.unqualified);
      return new ThisValue(position,this.theClass.getType());
    }
  }
  return instance;
}
Program: 83571
Project: 83571
Buggy source:
public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance);

Fixed version (ground truth):
public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context);
Program: 83572
Project: 83572
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  if (instance != null) {
    if ((this.modifiers & Modifiers.STATIC) != 0) {
      if (instance.valueTag() != IValue.CLASS_ACCESS) {
        markers.add(position,"String_Node_Str",this.name.unqualified);
        return null;
      }
    }
 else     if (instance.valueTag() == IValue.CLASS_ACCESS) {
      markers.add(position,"String_Node_Str",this.name.unqualified);
    }
  }
 else   if ((this.modifiers & Modifiers.STATIC) == 0) {
    markers.add(position,"String_Node_Str",this.name.unqualified);
    return new ThisValue(position,this.theClass.getType());
  }
  return instance;
}
Program: 83573
Project: 83573
Buggy source:
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance){
  return instance;
}

Fixed version (ground truth):
@Override public IValue checkAccess(MarkerList markers,ICodePosition position,IValue instance,IContext context){
  return instance;
}
Program: 83574
Project: 83574
Buggy source:
@Override public void checkArguments(MarkerList markers,IArguments arguments){
  int len=arguments.size();
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    len=this.parameterCount - 1;
    arguments.checkVarargsValue(len,this.parameters[len],markers,this.type);
    for (int i=0; i < len; i++) {
      arguments.checkValue(i,this.parameters[i],markers,this.type);
    }
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    arguments.checkValue(i,this.parameters[i],markers,this.type);
  }
}

Fixed version (ground truth):
@Override public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments){
  int len=arguments.size();
  if ((this.modifiers & Modifiers.VARARGS) != 0) {
    len=this.parameterCount - 1;
    arguments.checkVarargsValue(len,this.parameters[len],markers,this.type);
    for (int i=0; i < len; i++) {
      arguments.checkValue(i,this.parameters[i],markers,this.type);
    }
    return;
  }
  for (int i=0; i < this.parameterCount; i++) {
    arguments.checkValue(i,this.parameters[i],markers,this.type);
  }
}
Program: 83575
Project: 83575
Buggy source:
public void checkArguments(MarkerList markers,IArguments arguments);

Fixed version (ground truth):
public void checkArguments(MarkerList markers,ICodePosition position,IContext context,IArguments arguments);
Program: 83576
Project: 83576
Buggy source:
public IValue checkArguments(MarkerList markers,IValue instance,IArguments arguments,ITypeContext typeContext);

Fixed version (ground truth):
public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext);
Program: 83577
Project: 83577
Buggy source:
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getVisibility(this)) {
case IContext.STATIC:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.SEALED:
markers.add(position,"String_Node_Str",this.name);
break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
if ((this.modifiers & Modifiers.PREFIX) != 0) {
this.checkMutating(markers,arguments.getFirstValue());
}
 else if (instance != null) {
this.checkMutating(markers,instance);
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}

Fixed version (ground truth):
@Override public void checkCall(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if ((this.modifiers & Modifiers.DEPRECATED) != 0) {
    markers.add(position,"String_Node_Str",this.name);
  }
switch (context.getVisibility(this)) {
case IContext.STATIC:
    markers.add(position,"String_Node_Str",this.name);
  break;
case IContext.SEALED:
markers.add(position,"String_Node_Str",this.name);
break;
case IContext.INVISIBLE:
markers.add(position,"String_Node_Str",this.name);
break;
}
if ((this.modifiers & Modifiers.PREFIX) != 0) {
IValue value=arguments.getFirstValue();
this.checkMutating(markers,value != null ? value : instance);
}
 else if (instance != null) {
this.checkMutating(markers,instance);
}
for (int i=0; i < this.exceptionCount; i++) {
IType type=this.exceptions[i];
if (!Types.RUNTIME_EXCEPTION.isSuperTypeOf(type) && !context.handleException(type)) {
markers.add(position,"String_Node_Str",type.toString());
}
}
}