nus-yam/ex-repair huggingface dataset:
Program: 83472
Project: 83472
Buggy source:
private boolean computeVariable(REPLVariable field){
  this.currentClassName="String_Node_Str" + classIndex++;
  MarkerList markers=new MarkerList();
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    return false;
  }
  field.foldConstants();
  for (  IClassCompilable icc : this.innerClassList) {
    try {
      String fileName=icc.getFileName();
      byte[] bytes=ClassWriter.compile(icc);
      ReflectUtils.unsafe.defineClass(fileName,bytes,0,bytes.length,null,null);
    }
 catch (    Throwable t) {
      t.printStackTrace();
    }
  }
  field.compute(this.currentClassName,this.compilableList);
  this.compilableList.clear();
  this.innerClassList.clear();
  return true;
}

Fixed version (ground truth):
private boolean computeVariable(REPLVariable field){
  this.currentClassName="String_Node_Str" + classIndex++;
  MarkerList markers=new MarkerList();
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    this.compilableList.clear();
    this.innerClassList.clear();
    return false;
  }
  field.foldConstants();
  for (  IClassCompilable icc : this.innerClassList) {
    try {
      String fileName=icc.getFileName();
      byte[] bytes=ClassWriter.compile(icc);
      ReflectUtils.unsafe.defineClass(fileName,bytes,0,bytes.length,null,null);
    }
 catch (    Throwable t) {
      t.printStackTrace();
    }
  }
  field.compute(this.currentClassName,this.compilableList);
  this.compilableList.clear();
  this.innerClassList.clear();
  return true;
}
Program: 83473
Project: 83473
Buggy source:
@Override public void addField(IField field){
  this.currentClassName="String_Node_Str" + classIndex++;
  REPLVariable var=new REPLVariable(field.getPosition(),field.getName(),field.getType(),field.getValue());
  if (this.computeVariable(var)) {
    this.variables.put(var.name,var);
    System.out.println(var.toString());
  }
}

Fixed version (ground truth):
@Override public void addField(IField field){
  this.currentClassName="String_Node_Str" + classIndex++;
  REPLVariable var=new REPLVariable(field.getPosition(),field.getName(),field.getType(),field.getValue());
  var.setAnnotations(field.getAnnotations(),field.annotationCount());
  var.modifiers=field.getModifiers();
  if (this.computeVariable(var)) {
    this.variables.put(var.name,var);
    System.out.println(var.toString());
  }
}
Program: 83474
Project: 83474
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
    if (value != null) {
      value.writeExpression(writer);
    }
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.type.getExtendedName();
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    writer.writeFieldInsn(Opcodes.PUTSTATIC,owner,name,desc);
  }
 else {
    writer.writeFieldInsn(Opcodes.PUTFIELD,owner,name,desc);
  }
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) throws BytecodeException {
  if (instance != null) {
    instance.writeExpression(writer);
  }
  if (value != null) {
    value.writeExpression(writer);
  }
  String owner=this.theClass.getInternalName();
  String name=this.name.qualified;
  String desc=this.type.getExtendedName();
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    writer.writeFieldInsn(Opcodes.PUTSTATIC,owner,name,desc);
  }
 else {
    writer.writeFieldInsn(Opcodes.PUTFIELD,owner,name,desc);
  }
}
Program: 83475
Project: 83475
Buggy source:
public void pop() throws StackUnderflowException {
  Object o=this.stack[--this.stackCount];
  if (o == LONG || o == DOUBLE) {
    this.actualStackCount-=2;
  }
 else {
    this.actualStackCount--;
  }
}

Fixed version (ground truth):
public void pop() throws StackUnderflowException {
  if (this.stackCount == 0) {
    throw new StackUnderflowException();
  }
  Object o=this.stack[--this.stackCount];
  if (o == LONG || o == DOUBLE) {
    this.actualStackCount-=2;
  }
 else {
    this.actualStackCount--;
  }
}
Program: 83477
Project: 83477
Buggy source:
@Override public void setValue(IValue value){
  if (this.mode == WHILE) {
    this.statement.action=value;
  }
 else   if (this.mode == CONDITION_END) {
    this.statement.condition=value;
  }
}

Fixed version (ground truth):
@Override public void setValue(IValue value){
  if (this.mode == WHILE) {
    this.statement.action=value;
  }
 else   if (this.mode == END) {
    this.statement.condition=value;
  }
}
Program: 83478
Project: 83478
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == DO) {
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=WHILE;
    return;
  }
  int type=token.type();
  if (this.mode == WHILE) {
    if (type == Keywords.WHILE) {
      this.mode=CONDITION;
      return;
    }
    if (ParserUtil.isTerminator(type)) {
      if (token.next().type() == Keywords.WHILE) {
        pm.skip(1);
        this.mode=CONDITION;
        return;
      }
    }
    pm.popParser(true);
    return;
  }
  if (this.mode == CONDITION) {
    if (type == Symbols.OPEN_PARENTHESIS) {
      pm.pushParser(new ExpressionParser(this));
      this.mode=CONDITION_END;
      return;
    }
    pm.pushParser(new ExpressionParser(this));
    this.mode=CONDITION_END;
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == CONDITION_END) {
    if (type == Symbols.CLOSE_PARENTHESIS) {
      pm.popParser();
      return;
    }
    pm.popParser();
    throw new SyntaxError(token,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == DO) {
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=WHILE;
    return;
  }
  int type=token.type();
  if (this.mode == WHILE) {
    if (type == Keywords.WHILE) {
      this.mode=END;
      pm.pushParser(new ExpressionParser(this));
      return;
    }
    if (type == Symbols.SEMICOLON) {
      if (token.next().type() == Keywords.WHILE) {
        this.mode=END;
        pm.skip(1);
        pm.pushParser(new ExpressionParser(this));
        return;
      }
    }
    pm.popParser(true);
    return;
  }
  if (this.mode == END) {
    pm.popParser(true);
    return;
  }
}
Program: 83479
Project: 83479
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == -1) {
    pm.popParser(true);
    return;
  }
  int type=token.type();
  if (this.mode == IF) {
    this.mode=CONDITION_END;
    pm.pushParser(new ExpressionParser(this));
    if (type == Symbols.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CONDITION_END) {
    this.mode=THEN;
    if (type == Symbols.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == THEN) {
    if (ParserUtil.isTerminator(type)) {
      pm.popParser(true);
      return;
    }
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=ELSE;
    return;
  }
  if (this.mode == ELSE) {
    if (ParserUtil.isTerminator(type)) {
      if (token.next().type() == Keywords.ELSE) {
        return;
      }
      pm.popParser(true);
      return;
    }
    if (type == Keywords.ELSE) {
      pm.pushParser(new ExpressionParser(this));
      this.mode=-1;
      return;
    }
    pm.popParser(true);
    return;
  }
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  if (this.mode == -1) {
    pm.popParser(true);
    return;
  }
  int type=token.type();
  if (this.mode == IF) {
    this.mode=CONDITION_END;
    pm.pushParser(new ExpressionParser(this));
    if (type == Symbols.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CONDITION_END) {
    this.mode=THEN;
    if (type == Symbols.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == THEN) {
    if (ParserUtil.isTerminator(type)) {
      pm.popParser(true);
      return;
    }
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=ELSE;
    return;
  }
  if (this.mode == ELSE) {
    if (ParserUtil.isTerminator(type)) {
      IToken next=token.getNext();
      if (next != null && next.type() == Keywords.ELSE) {
        return;
      }
      pm.popParser(true);
      return;
    }
    if (type == Keywords.ELSE) {
      pm.pushParser(new ExpressionParser(this));
      this.mode=-1;
      return;
    }
    pm.popParser(true);
    return;
  }
}
Program: 83480
Project: 83480
Buggy source:
@Override public boolean isSuperTypeOf(IType type){
  int arrayDims=type.getArrayDimensions();
  if (arrayDims == 0) {
    return false;
  }
  int thisDims=this.getArrayDimensions();
  if (arrayDims > thisDims) {
    return this.type.getTheClass() == Types.OBJECT_CLASS;
  }
  IType elementType=type.getElementType();
  if (elementType.isPrimitive() != this.type.isPrimitive()) {
    return false;
  }
  return this.type.isSuperTypeOf(elementType);
}

Fixed version (ground truth):
@Override public boolean isSuperTypeOf(IType type){
  if (!type.isArrayType()) {
    return false;
  }
  return this.type.isSuperTypeOf(type.getElementType());
}
Program: 83481
Project: 83481
Buggy source:
private Annotation[] getAnnotations(){
  Annotation[] a=new Annotation[this.annotationCount];
  System.arraycopy(this.annotations,0,a,0,this.annotationCount);
  return a;
}

Fixed version (ground truth):
@Override public Annotation[] getAnnotations(){
  Annotation[] a=new Annotation[this.annotationCount];
  System.arraycopy(this.annotations,0,a,0,this.annotationCount);
  return a;
}
Program: 83482
Project: 83482
Buggy source:
private Annotation[] getAnnotations(){
  Annotation[] a=new Annotation[this.annotationCount];
  System.arraycopy(this.annotations,0,a,0,this.annotationCount);
  return a;
}

Fixed version (ground truth):
@Override public Annotation[] getAnnotations(){
  Annotation[] a=new Annotation[this.annotationCount];
  System.arraycopy(this.annotations,0,a,0,this.annotationCount);
  return a;
}
Program: 83483
Project: 83483
Buggy source:
protected void processValue(){
  if (this.value == null) {
    return;
  }
  MarkerList markers=new MarkerList();
  this.currentClassName="String_Node_Str" + classIndex++;
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  IValue value=this.value;
  IType type=Types.UNKNOWN;
  ICodePosition position=CODE_POSITION;
  this.value=null;
  REPLVariable field=new REPLVariable(position,name,type,value);
  field.modifiers=Modifiers.FINAL;
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    return;
  }
  field.foldConstants();
  for (  IClassCompilable icc : this.innerClassList) {
    try {
      String fileName=icc.getFileName();
      byte[] bytes=ClassWriter.compile(icc);
      ReflectUtils.unsafe.defineClass(fileName,bytes,0,bytes.length,null,null);
    }
 catch (    Throwable t) {
      t.printStackTrace();
    }
  }
  field.compute(this.currentClassName,this.compilableList);
  this.compilableList.clear();
  this.innerClassList.clear();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}

Fixed version (ground truth):
protected void processValue(){
  if (this.value == null) {
    return;
  }
  IValue value=this.value;
  MarkerList markers=new MarkerList();
  this.currentClassName="String_Node_Str" + classIndex++;
  this.value=null;
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  REPLVariable field=new REPLVariable(CODE_POSITION,name,Types.UNKNOWN,value);
  field.modifiers=Modifiers.FINAL;
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    return;
  }
  field.foldConstants();
  for (  IClassCompilable icc : this.innerClassList) {
    try {
      String fileName=icc.getFileName();
      byte[] bytes=ClassWriter.compile(icc);
      ReflectUtils.unsafe.defineClass(fileName,bytes,0,bytes.length,null,null);
    }
 catch (    Throwable t) {
      t.printStackTrace();
    }
  }
  field.compute(this.currentClassName,this.compilableList);
  this.compilableList.clear();
  this.innerClassList.clear();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}
Program: 83484
Project: 83484
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(this.value);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.value.getClass().isArray()) {
    ObjectArray.toString(this.value,buffer);
    return;
  }
  buffer.append(this.value);
}
Program: 83485
Project: 83485
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value) throws BytecodeException {
  if (this.className == null) {
    writer.writeInsn(Opcodes.AUTO_POP);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.PUTSTATIC,this.className,"String_Node_Str",extended);
}
Program: 83486
Project: 83486
Buggy source:
@Override public ICompilationUnit createUnit(Package pack,CodeFile inputFile,File outputFile){
  return new DyvilHeader(pack,inputFile,outputFile);
}

Fixed version (ground truth):
@Override public ICompilationUnit createUnit(Package pack,CodeFile inputFile,File outputFile){
  DyvilHeader header=new DyvilHeader(pack,inputFile,outputFile);
  pack.addHeader(header);
  return header;
}
Program: 83487
Project: 83487
Buggy source:
public static void writeToString(MethodWriter writer,IType type) throws BytecodeException {
  if (type.isArrayType()) {
    writer.writeInsn(Opcodes.SWAP);
    writer.writeInsn(Opcodes.DUP_X1);
    writeArrayToString(writer,type.getElementType());
    return;
  }
  StringBuilder desc=new StringBuilder().append('(');
  if (type.isPrimitive()) {
    type.appendExtendedName(desc);
  }
 else   if (type.classEquals(Types.STRING)) {
    desc.append("String_Node_Str");
  }
 else {
    desc.append("String_Node_Str");
  }
  desc.append("String_Node_Str");
  writer.writeInvokeInsn(INVOKEVIRTUAL,"String_Node_Str","String_Node_Str",desc.toString(),false);
  return;
}

Fixed version (ground truth):
public static void writeToString(MethodWriter writer,IType type) throws BytecodeException {
  if (type.isArrayType()) {
    writer.writeInsn(Opcodes.SWAP);
    writer.writeInsn(Opcodes.DUP_X1);
    writeArrayToString(writer,type.getElementType());
    return;
  }
  StringBuilder desc=new StringBuilder().append('(');
  if (type.isPrimitive()) {
    type.appendExtendedName(desc);
  }
 else   if (type.equals(Types.STRING)) {
    desc.append("String_Node_Str");
  }
 else {
    desc.append("String_Node_Str");
  }
  desc.append("String_Node_Str");
  writer.writeInvokeInsn(INVOKEVIRTUAL,"String_Node_Str","String_Node_Str",desc.toString(),false);
  return;
}
Program: 83488
Project: 83488
Buggy source:
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeArgumentsAndInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeArgumentsAndInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}
Program: 83489
Project: 83489
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeArgumentsAndInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments) throws BytecodeException {
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeArgumentsAndInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}
Program: 83490
Project: 83490
Buggy source:
public static String frameTypeName(Object o){
  if (o == BYTE) {
    return "String_Node_Str";
  }
  if (o == SHORT) {
    return "String_Node_Str";
  }
  if (o == CHAR) {
    return "String_Node_Str";
  }
  if (o == INT) {
    return "String_Node_Str";
  }
  if (o == LONG) {
    return "String_Node_Str";
  }
  if (o == FLOAT) {
    return "String_Node_Str";
  }
  if (o == DOUBLE) {
    return "String_Node_Str";
  }
  if (o == NULL) {
    return "String_Node_Str";
  }
  if (o == UNINITIALIZED_THIS) {
    return "String_Node_Str";
  }
  if (o == null) {
    return "String_Node_Str";
  }
  return o.toString();
}

Fixed version (ground truth):
public static String frameTypeName(Object o){
  if (o == BOOLEAN) {
    return "String_Node_Str";
  }
  if (o == BYTE) {
    return "String_Node_Str";
  }
  if (o == SHORT) {
    return "String_Node_Str";
  }
  if (o == CHAR) {
    return "String_Node_Str";
  }
  if (o == INT) {
    return "String_Node_Str";
  }
  if (o == LONG) {
    return "String_Node_Str";
  }
  if (o == FLOAT) {
    return "String_Node_Str";
  }
  if (o == DOUBLE) {
    return "String_Node_Str";
  }
  if (o == NULL) {
    return "String_Node_Str";
  }
  if (o == UNINITIALIZED_THIS) {
    return "String_Node_Str";
  }
  if (o == null) {
    return "String_Node_Str";
  }
  return o.toString();
}
Program: 83491
Project: 83491
Buggy source:
@Override public Iterator<T> iterator(){
  return new Iterator<T>(){
    private T current=SimpleRange.this.first;
    @Override public T next(){
      if (this.current.$gt(SimpleRange.this.last)) {
        throw new NoSuchElementException("String_Node_Str");
      }
      T c=this.current;
      this.current=this.current.next();
      return c;
    }
    @Override public boolean hasNext(){
      return this.current.$lt$eq(SimpleRange.this.last);
    }
  }
;
}

Fixed version (ground truth):
@Override public Iterator<T> iterator(){
  return new Iterator<T>(){
    private T current=SimpleRange.this.first;
    @Override public T next(){
      if (this.current.$gt(SimpleRange.this.last)) {
        throw new NoSuchElementException("String_Node_Str");
      }
      T c=this.current;
      this.current=this.current.next();
      return c;
    }
    @Override public boolean hasNext(){
      return this.current.$lt$eq(SimpleRange.this.last);
    }
    @Override public String toString(){
      return "String_Node_Str" + SimpleRange.this + "String_Node_Str";
    }
  }
;
}
Program: 83492
Project: 83492
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.position,context,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.checkTypes(markers,context);
}
Program: 83493
Project: 83493
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.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;
}

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;
  }
  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;
  }
  if (!this.typeHint && this.type.equals(this.value.getType())) {
    markers.add(this.position,"String_Node_Str");
    this.typeHint=true;
  }
  this.value.checkTypes(markers,context);
  return this;
}
Program: 83494
Project: 83494
Buggy source:
private IValue withElementType(IType type,IType elementType){
  IValue value1=this.value1.withType(elementType);
  if (value1 == null) {
    return null;
  }
  IValue value2=this.value2.withType(elementType);
  if (value2 == null) {
    return null;
  }
  this.value1=value1;
  this.value2=value2;
  this.type=type;
  this.elementType=elementType;
  return this;
}

Fixed version (ground truth):
private IValue withElementType(IType type,IType elementType){
  if (!this.value1.isType(elementType)) {
    return null;
  }
  if (!this.value2.isType(elementType)) {
    return null;
  }
  this.type=type;
  this.elementType=elementType;
  return this;
}
Program: 83495
Project: 83495
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value1.checkTypes(markers,context);
  this.value2.checkTypes(markers,context);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IValue value1=this.value1.withType(this.elementType);
  if (value1 == null) {
  }
 else {
    this.value1=value1;
  }
  value1=this.value2.withType(this.elementType);
  if (value1 == null) {
  }
 else {
    this.value2=value1;
  }
  this.value1.checkTypes(markers,context);
  this.value2.checkTypes(markers,context);
}
Program: 83496
Project: 83496
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.position,context,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: 83497
Project: 83497
Buggy source:
public static void writeToString(MethodWriter writer,IType type) throws BytecodeException {
  if (type.isArrayType()) {
    writer.writeInsn(Opcodes.SWAP);
    writer.writeInsn(Opcodes.DUP_X1);
    writeArrayToString(writer,type.getElementType());
    return;
  }
  StringBuilder desc=new StringBuilder().append('(');
  if (type.isPrimitive()) {
    type.appendExtendedName(desc);
  }
 else   if (type.equals(Types.STRING)) {
    desc.append("String_Node_Str");
  }
 else {
    desc.append("String_Node_Str");
  }
  desc.append("String_Node_Str");
  writer.writeInvokeInsn(INVOKEVIRTUAL,"String_Node_Str","String_Node_Str",desc.toString(),false);
  return;
}

Fixed version (ground truth):
public static void writeToString(MethodWriter writer,IType type) throws BytecodeException {
  if (type.isArrayType()) {
    writer.writeInsn(Opcodes.SWAP);
    writer.writeInsn(Opcodes.DUP_X1);
    writeArrayToString(writer,type.getElementType());
    return;
  }
  StringBuilder desc=new StringBuilder().append('(');
  if (type.isPrimitive()) {
    type.appendExtendedName(desc);
  }
 else   if (type.classEquals(Types.STRING)) {
    desc.append("String_Node_Str");
  }
 else {
    desc.append("String_Node_Str");
  }
  desc.append("String_Node_Str");
  writer.writeInvokeInsn(INVOKEVIRTUAL,"String_Node_Str","String_Node_Str",desc.toString(),false);
  return;
}
Program: 83498
Project: 83498
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.condition != null) {
    this.condition.checkTypes(markers,this);
  }
  if (this.type != Types.UNKNOWN) {
    IClass iclass=context.getThisClass();
    IDyvilHeader unit=iclass.getUnit();
    this.internalClassName=iclass.getInternalName() + "String_Node_Str" + unit.innerClassCount();
    unit.addInnerClass(this);
    if (this.pattern != null) {
      this.pattern.resolve(markers,context);
      IType type1=this.type.resolveType(PAR_TYPE);
      this.pattern=this.pattern.withType(type1);
      this.pattern.checkTypes(markers,context);
    }
    if (this.value != null) {
      IType type1=this.type.resolveType(RETURN_TYPE);
      this.value=this.value.withType(type1);
    }
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
  this.context=null;
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.context=context;
  if (this.condition != null) {
    this.condition.checkTypes(markers,this);
  }
  if (this.type != Types.UNKNOWN) {
    if (this.type == null) {
      this.getType();
    }
    IClass iclass=context.getThisClass();
    IDyvilHeader unit=iclass.getUnit();
    this.internalClassName=iclass.getInternalName() + "String_Node_Str" + unit.innerClassCount();
    unit.addInnerClass(this);
    if (this.pattern != null) {
      this.pattern.resolve(markers,context);
      IType type1=this.type.resolveType(PAR_TYPE);
      this.pattern=this.pattern.withType(type1);
      this.pattern.checkTypes(markers,context);
    }
    if (this.value != null) {
      IType type1=this.type.resolveType(RETURN_TYPE);
      this.value=this.value.withType(type1);
    }
  }
  if (this.value != null) {
    this.value.checkTypes(markers,this);
  }
  this.context=null;
}
Program: 83500
Project: 83500
Buggy source:
@Override public IType getType(){
  if (this.type == null) {
    GenericType gt=new GenericType(PARTIALFUNCTION_CLASS);
    IType t1=this.pattern.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    t1=this.value.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    return this.type=gt;
  }
  return this.type;
}

Fixed version (ground truth):
@Override public IType getType(){
  if (this.type == null) {
    GenericType gt=new GenericType(PARTIALFUNCTION_CLASS);
    IType t1=this.pattern.getType();
    if (t1.isPrimitive()) {
      t1=t1.getReferenceType();
    }
    gt.addType(t1);
    if (this.value != null) {
      t1=this.value.getType();
      if (t1.isPrimitive()) {
        t1=t1.getReferenceType();
      }
      gt.addType(t1);
    }
 else {
      gt.addType(new Type(Types.VOID_CLASS));
    }
    return this.type=gt;
  }
  return this.type;
}
Program: 83501
Project: 83501
Buggy source:
public default IValue withType(IType type){
  IType thisType=this.getType();
  if (thisType == null) {
    return null;
  }
  if (!type.isSuperTypeOf(thisType)) {
    return null;
  }
  boolean primitive=this.isPrimitive();
  if (primitive != type.isPrimitive()) {
    if (primitive) {
      return new BoxedValue(this,thisType.getBoxMethod());
    }
    return new BoxedValue(this,type.getUnboxMethod());
  }
  return this;
}

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

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.value=this.value.resolve(markers,context);
  IType type=this.value.getType();
  for (int i=0; i < this.caseCount; i++) {
    CaseStatement c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.pattern;
    pattern=pattern.resolve(markers,context);
    if (pattern.isExhaustive()) {
      if (c.condition == null) {
        this.exhaustive=true;
      }
    }
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
 else {
      pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
    c.pattern=pattern;
    this.cases[i].resolve(markers,context);
  }
  if (type == Types.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}
Program: 83503
Project: 83503
Buggy source:
public static MatchExpression getMatchExpression(IValue arg1,IValue arg2){
  if (arg2.valueTag() == IValue.STATEMENT_LIST) {
    IValueList list=(IValueList)arg2;
    int len=list.valueCount();
    CaseStatement[] cases=new CaseStatement[len];
    for (int i=0; i < len; i++) {
      IValue v=list.getValue(i);
      if (v.valueTag() != IValue.CASE_STATEMENT) {
        return null;
      }
      cases[i]=(CaseStatement)v;
      cases[i].setMatchCase();
    }
    return new MatchExpression(arg1,cases);
  }
  if (arg2.valueTag() == IValue.CASE_STATEMENT) {
    return new MatchExpression(arg1,new CaseStatement[]{(CaseStatement)arg2});
  }
  return null;
}

Fixed version (ground truth):
public static MatchExpression getMatchExpression(IValue arg1,IValue arg2){
  if (arg2.valueTag() == IValue.STATEMENT_LIST) {
    IValueList list=(IValueList)arg2;
    int len=list.valueCount();
    CaseStatement[] cases=new CaseStatement[len];
    for (int i=0; i < len; i++) {
      IValue v=list.getValue(i);
      if (v.valueTag() != IValue.CASE_STATEMENT) {
        return null;
      }
      cases[i]=(CaseStatement)v;
      cases[i].setMatchCase();
    }
    return new MatchExpression(arg1,cases);
  }
  if (arg2.valueTag() == IValue.CASE_STATEMENT) {
    CaseStatement cs=(CaseStatement)arg2;
    cs.setMatchCase();
    return new MatchExpression(arg1,new CaseStatement[]{cs});
  }
  return null;
}
Program: 83504
Project: 83504
Buggy source:
@Override public boolean isExhaustive(){
  return true;
}

Fixed version (ground truth):
@Override public boolean isExhaustive(){
  return this.type == Types.ANY || this.type == Types.UNKNOWN;
}
Program: 83505
Project: 83505
Buggy source:
@Override public IPattern withType(IType type){
  this.type=type;
  return this;
}

Fixed version (ground truth):
@Override public IPattern withType(IType type){
  if (this.type == Types.ANY || this.type == Types.UNKNOWN) {
    this.type=type;
    return this;
  }
  return type.isSuperTypeOf(this.type) ? this : null;
}
Program: 83506
Project: 83506
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
}

Fixed version (ground truth):
@Override public IPattern resolve(MarkerList markers,IContext context){
  this.type=this.type.resolve(markers,context);
  for (int i=0; i < this.patternCount; i++) {
    this.patterns[i]=this.patterns[i].resolve(markers,context);
  }
  return this;
}
Program: 83507
Project: 83507
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  int paramCount=iclass.parameterCount();
  if (this.patternCount != paramCount) {
    Marker m=markers.create(this.position,"String_Node_Str",this.type.toString());
    m.addInfo("String_Node_Str" + this.patternCount);
    m.addInfo("String_Node_Str" + paramCount);
    return;
  }
  for (int i=0; i < paramCount; i++) {
    IParameter param=iclass.getParameter(i);
    IType type=param.getType().getConcreteType(this.type);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(this.position,"String_Node_Str",param.getName());
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  int paramCount=iclass.parameterCount();
  if (this.patternCount != paramCount) {
    Marker m=markers.create(this.position,"String_Node_Str",this.type.toString());
    m.addInfo("String_Node_Str" + this.patternCount);
    m.addInfo("String_Node_Str" + paramCount);
    return;
  }
  for (int i=0; i < paramCount; i++) {
    IParameter param=iclass.getParameter(i);
    IType type=param.getType().getConcreteType(this.type);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(this.position,"String_Node_Str",param.getName());
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
  }
}
Program: 83508
Project: 83508
Buggy source:
public default void resolve(MarkerList markers,IContext context){
}

Fixed version (ground truth):
public default IPattern resolve(MarkerList markers,IContext context){
  return this;
}
Program: 83509
Project: 83509
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  ITypeList typeList=(ITypeList)this.tupleType;
  for (int i=0; i < this.patternCount; i++) {
    IType type=typeList.getType(i);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern1;
    }
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  ITypeList typeList=(ITypeList)this.tupleType;
  for (int i=0; i < this.patternCount; i++) {
    IType type=typeList.getType(i);
    IPattern pattern=this.patterns[i];
    IPattern pattern1=pattern.withType(type);
    if (pattern1 == null) {
      Marker m=markers.create(pattern.getPosition(),"String_Node_Str");
      m.addInfo("String_Node_Str" + pattern.getType());
      m.addInfo("String_Node_Str" + type);
    }
 else {
      this.patterns[i]=pattern=pattern1;
    }
    pattern.checkTypes(markers,context);
  }
}
Program: 83510
Project: 83510
Buggy source:
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    varIndex=writer.localCount();
    writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  }
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.INSTANCEOF,this.type.getInternalName());
  writer.writeJumpInsn(Opcodes.IFEQ,elseLabel);
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
  this.pattern.writeInvJump(writer,-1,elseLabel);
  writer.resetLocals(varIndex);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    varIndex=writer.localCount();
    writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  }
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeTypeInsn(Opcodes.INSTANCEOF,this.type.getInternalName());
  writer.writeJumpInsn(Opcodes.IFEQ,elseLabel);
  if (this.pattern.getPatternType() != WILDCARD) {
    writer.writeVarInsn(Opcodes.ALOAD,varIndex);
    writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    this.pattern.writeInvJump(writer,-1,elseLabel);
  }
}
Program: 83511
Project: 83511
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  this.pattern.toString(prefix,buffer);
  buffer.append("String_Node_Str");
  this.type.toString(prefix,buffer);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.pattern != null) {
    this.pattern.toString(prefix,buffer);
  }
  if (!this.pattern.isType(this.type)) {
    buffer.append("String_Node_Str");
    this.type.toString(prefix,buffer);
  }
}
Program: 83512
Project: 83512
Buggy source:
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    writer.writeInsn(Opcodes.AUTO_POP);
  }
}
Program: 83513
Project: 83513
Buggy source:
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  writer.writeInsn(Opcodes.AUTO_POP);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,int varIndex,Label elseLabel) throws BytecodeException {
  if (varIndex < 0) {
    writer.writeInsn(Opcodes.AUTO_POP);
  }
}
Program: 83515
Project: 83515
Buggy source:
protected void processValue(){
  if (this.value == null) {
    return;
  }
  MarkerList markers=new MarkerList();
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  IValue value=this.value;
  IType type=Types.UNKNOWN;
  ICodePosition position=CODE_POSITION;
  this.value=null;
  REPLVariable field=new REPLVariable(position,name,type,value);
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  field.foldConstants();
  if (this.reportErrors(markers)) {
    return;
  }
  field.compute();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}

Fixed version (ground truth):
protected void processValue(){
  if (this.value == null) {
    return;
  }
  MarkerList markers=new MarkerList();
  Name name=Name.getQualified("String_Node_Str" + resultIndex);
  IValue value=this.value;
  IType type=Types.UNKNOWN;
  ICodePosition position=CODE_POSITION;
  this.value=null;
  REPLVariable field=new REPLVariable(position,name,type,value);
  field.modifiers=Modifiers.FINAL;
  field.resolveTypes(markers,this);
  field.resolve(markers,this);
  field.checkTypes(markers,this);
  field.check(markers,this);
  if (this.reportErrors(markers)) {
    return;
  }
  field.foldConstants();
  field.compute();
  if (field.getType() != Types.VOID) {
    this.variables.put(name,field);
    System.out.println(field.toString());
    resultIndex++;
  }
}
Program: 83516
Project: 83516
Buggy source:
protected void compute(){
  if (this.className != null || this.value.isConstant())   return;
  try {
    this.className="String_Node_Str" + classID++;
    Class c=generateClass(this.value,this.type,this.className);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}

Fixed version (ground truth):
protected void compute(){
  if (this.className != null || isConstant(this.value))   return;
  try {
    this.className="String_Node_Str" + classID++;
    Class c=generateClass(this.value,this.type,this.className);
    if (this.type != Types.VOID) {
      java.lang.reflect.Field[] fields=c.getDeclaredFields();
      Object result=fields[0].get(null);
      IValue v=IValue.fromObject(result);
      if (v != null) {
        this.value=v;
      }
 else {
        this.value=new REPLResult(result);
      }
    }
 else {
      ReflectUtils.unsafe.ensureClassInitialized(c);
    }
  }
 catch (  ExceptionInInitializerError t) {
    Throwable ex=t.getCause();
    System.err.println(ex.getClass().getCanonicalName() + "String_Node_Str" + ex.getMessage());
    StackTraceElement[] trace=ex.getStackTrace();
    int len=trace.length - 10;
    for (int i=0; i < len; i++) {
      System.err.println("String_Node_Str" + trace[i]);
    }
    this.value=this.type.getDefaultValue();
  }
catch (  Throwable t) {
    t.printStackTrace();
  }
}
Program: 83517
Project: 83517
Buggy source:
@Override public void writeGet(MethodWriter writer,IValue instance) throws BytecodeException {
  if (this.value.isConstant()) {
    this.value.writeExpression(writer);
    return;
  }
  if (this.className == null) {
    this.type.writeDefaultValue(writer);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.GETSTATIC,this.className,"String_Node_Str",extended);
}

Fixed version (ground truth):
@Override public void writeGet(MethodWriter writer,IValue instance) throws BytecodeException {
  if (isConstant(this.value)) {
    this.value.writeExpression(writer);
    return;
  }
  if (this.className == null) {
    this.type.writeDefaultValue(writer);
    return;
  }
  String extended=this.type.getExtendedName();
  writer.writeFieldInsn(Opcodes.GETSTATIC,this.className,"String_Node_Str",extended);
}
Program: 83518
Project: 83518
Buggy source:
private IDyvilHeader loadHeader(String fileName,String name,Library library){
  InputStream is=library.getInputStream(fileName);
  if (is != null) {
    IDyvilHeader header=HeaderFile.read(is);
    this.units.add(header);
    return header;
  }
  return null;
}

Fixed version (ground truth):
private IDyvilHeader loadHeader(String fileName,String name,Library library){
  InputStream is=library.getInputStream(fileName);
  if (is != null) {
    DyvilHeader header=HeaderFile.read(is);
    header.pack=this;
    this.units.add(header);
    return header;
  }
  return null;
}
Program: 83519
Project: 83519
Buggy source:
@Override public void addInclude(IncludeDeclaration component){
  if (this.includes == null) {
    this.includes=new IncludeDeclaration[2];
    this.includes[0]=component;
    this.includeCount=1;
    if (!this.isHeader()) {
      this.inheritedOperators=new IdentityHashMap();
    }
  }
 else {
    int index=this.includeCount++;
    if (index >= this.includes.length) {
      IncludeDeclaration[] temp=new IncludeDeclaration[index + 1];
      System.arraycopy(this.includes,0,temp,0,this.includes.length);
      this.includes=temp;
    }
    this.includes[index]=component;
  }
  if (this.isHeader()) {
    this.markers.add(component.getPosition(),"String_Node_Str");
    return;
  }
  component.resolve(this.markers);
  component.addOperators(this.inheritedOperators);
}

Fixed version (ground truth):
@Override public void addInclude(IncludeDeclaration component){
  this.addIncludeToArray(component);
  if (this.isHeader()) {
    this.markers.add(component.getPosition(),"String_Node_Str");
    return;
  }
  component.resolve(this.markers);
  component.addOperators(this.inheritedOperators);
}