nus-yam/ex-repair huggingface dataset:
Program: 85137
Project: 85137
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (this.mode == NAME) {
    this.mode=BODY;
    if (ParserUtil.isIdentifier(type)) {
      this.node.setPosition(token.raw());
      this.node.name=token.nameValue();
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == BODY) {
    if (type == Symbols.OPEN_CURLY_BRACKET) {
      this.mode=PROPERTY_NAME;
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (type == Symbols.CLOSE_CURLY_BRACKET) {
    pm.popParser();
    return;
  }
  if (this.mode == PROPERTY_NAME) {
    if (ParserUtil.isIdentifier(type)) {
      this.mode=EQUALS;
      this.name=token.nameValue().qualified;
      return;
    }
    this.mode=PROPERTY_NAME;
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == EQUALS) {
    if (type == Tokens.EQUALS || type == Tokens.COLON) {
      pm.pushParser(new DWTValueParser(this));
      return;
    }
    this.mode=PROPERTY_NAME;
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == BODY_END) {
    throw new SyntaxError(token,"String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (this.mode == NAME) {
    this.mode=BODY;
    if (ParserUtil.isIdentifier(type)) {
      this.node.setPosition(token.raw());
      this.node.name=token.nameValue();
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == BODY) {
    if (type == Symbols.OPEN_CURLY_BRACKET) {
      this.mode=PROPERTY_NAME;
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (type == Symbols.CLOSE_CURLY_BRACKET) {
    pm.popParser();
    return;
  }
  if (this.mode == PROPERTY_NAME) {
    if (ParserUtil.isIdentifier(type)) {
      this.mode=EQUALS;
      this.name=token.nameValue().qualified;
      return;
    }
    this.mode=PROPERTY_NAME;
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == EQUALS) {
    if (type == Symbols.EQUALS || type == Symbols.COLON) {
      pm.pushParser(new DWTValueParser(this));
      return;
    }
    this.mode=PROPERTY_NAME;
    throw new SyntaxError(token,"String_Node_Str");
  }
  if (this.mode == BODY_END) {
    throw new SyntaxError(token,"String_Node_Str");
  }
}
Program: 85138
Project: 85138
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.checkTypes(markers,context);
    if (this.field != null && this.field.hasModifier(Modifiers.STATIC) && this.instance.getValueType() != CLASS_ACCESS) {
      markers.add(this.position,"String_Node_Str",this.name);
      this.instance=null;
      return;
    }
  }
 else   if (this.field.isField()) {
    markers.add(this.position,"String_Node_Str",this.name);
    this.instance=new ThisValue(this.position,this.field.getTheClass().getType());
  }
}

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.field.hasModifier(Modifiers.STATIC) && this.instance.getValueType() != CLASS_ACCESS) {
      markers.add(this.position,"String_Node_Str",this.name);
      this.instance=null;
      return;
    }
  }
 else   if (this.field != null && this.field.isField()) {
    markers.add(this.position,"String_Node_Str",this.name);
    this.instance=new ThisValue(this.position,this.field.getTheClass().getType());
  }
}
Program: 85139
Project: 85139
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  this.variable.writeSet(writer,null,this.variable.value);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  this.variable.index=writer.registerLocal(this.variable.type);
  this.variable.writeSet(writer,null,null);
}
Program: 85140
Project: 85140
Buggy source:
@Override public boolean resolve(IContext context,MarkerList markers){
  int len=this.arguments.size();
  if (len == 1) {
    IValue argument=this.arguments.getFirstValue();
    IValue operator;
    if (this.instance != null) {
      if ("String_Node_Str".equals(this.name)) {
        MatchExpression me=Operators.getMatchExpression(this.instance,argument);
        if (me != null) {
          me.resolve(markers,context);
          me.position=this.position;
          this.replacement=me;
          return false;
        }
      }
      argument=argument.resolve(markers,context);
      operator=Operators.get(this.instance,this.name,argument);
    }
 else {
      argument=argument.resolve(markers,context);
      operator=Operators.get(this.name,argument);
    }
    if (operator != null) {
      operator.setPosition(this.position);
      this.replacement=operator;
      return false;
    }
    this.arguments.setFirstValue(argument);
  }
 else {
    this.arguments.resolve(markers,context);
  }
  IMethod method=IAccess.resolveMethod(context,this.instance,this.qualifiedName,this.arguments);
  if (method != null) {
    this.method=method;
    return true;
  }
  if (len == 1 && this.instance != null && this.qualifiedName.endsWith("String_Node_Str")) {
    String s=this.qualifiedName.substring(0,this.qualifiedName.length() - 3);
    MethodMatch method1=this.instance.getType().resolveMethod(null,s,this.arguments);
    if (method1 != null) {
      AssignMethodCall call=new AssignMethodCall(this.position);
      call.method=method1.theMethod;
      call.instance=this.instance;
      call.arguments=this.arguments;
      call.name=this.name.substring(0,this.name.length() - 1);
      call.qualifiedName=s;
      call.dotless=this.dotless;
      this.replacement=call;
    }
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean resolve(IContext context,MarkerList markers){
  IValue op=this.resolveOperator(markers,context);
  if (op != null) {
    this.replacement=op;
    return false;
  }
  IMethod method=IAccess.resolveMethod(context,this.instance,this.qualifiedName,this.arguments);
  if (method != null) {
    this.method=method;
    return true;
  }
  if (this.arguments.size() == 1 && this.instance != null && this.qualifiedName.endsWith("String_Node_Str")) {
    String s=this.qualifiedName.substring(0,this.qualifiedName.length() - 3);
    MethodMatch method1=this.instance.getType().resolveMethod(null,s,this.arguments);
    if (method1 != null) {
      AssignMethodCall call=new AssignMethodCall(this.position);
      call.method=method1.theMethod;
      call.instance=this.instance;
      call.arguments=this.arguments;
      call.name=this.name.substring(0,this.name.length() - 1);
      call.qualifiedName=s;
      call.dotless=this.dotless;
      this.replacement=call;
    }
  }
  return false;
}
Program: 85141
Project: 85141
Buggy source:
@Override public void writeStatement(MethodWriter writer,int varIndex,Label elseLabel){
  int locals=writer.localCount();
  this.pattern.writeJump(writer,varIndex,elseLabel);
  if (this.condition != null) {
    this.condition.writeInvJump(writer,elseLabel);
  }
  this.value.writeStatement(writer);
  writer.removeLocals(writer.localCount() - locals);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer,int varIndex,Label elseLabel){
  int locals=writer.localCount();
  this.pattern.writeJump(writer,varIndex,elseLabel);
  if (this.condition != null) {
    this.condition.writeInvJump(writer,elseLabel);
  }
  this.value.writeStatement(writer);
  writer.resetLocals(locals);
}
Program: 85142
Project: 85142
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  IType type=this.value.getType();
  int var=writer.registerLocal(type);
  this.value.writeExpression(writer);
  writer.writeVarInsn(type.getStoreOpcode(),var);
  Label elseLabel=new Label();
  Label endLabel=new Label();
  for (int i=0; i < this.caseCount; ) {
    this.cases[i].writeStatement(writer,var,elseLabel);
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
    writer.writeFrameLabel(elseLabel);
    if (++i < this.caseCount) {
      elseLabel=new Label();
    }
  }
  writer.writeFrameLabel(elseLabel);
  this.writeError(writer,type,type.getLoadOpcode(),var);
  writer.removeLocals(1);
  writer.writeFrameLabel(endLabel);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  int locals=writer.localCount();
  IType type=this.value.getType();
  int var=writer.registerLocal(type);
  this.value.writeExpression(writer);
  writer.writeVarInsn(type.getStoreOpcode(),var);
  Label elseLabel=new Label();
  Label endLabel=new Label();
  for (int i=0; i < this.caseCount; ) {
    this.cases[i].writeStatement(writer,var,elseLabel);
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
    writer.writeFrameLabel(elseLabel);
    if (++i < this.caseCount) {
      elseLabel=new Label();
    }
  }
  writer.writeFrameLabel(elseLabel);
  this.writeError(writer,type,type.getLoadOpcode(),var);
  writer.resetLocals(locals);
  writer.writeFrameLabel(endLabel);
}
Program: 85143
Project: 85143
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  IType type=this.value.getType();
  this.value=this.value.resolve(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    ICase c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.getPattern();
    if (pattern.getPatternType() == IPattern.WILDCARD) {
      if (c.getCondition() == null) {
        this.exhaustive=true;
      }
    }
 else     if (!pattern.isType(type)) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
    this.cases[i]=c.resolve(markers,context);
  }
  if (type == Type.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  IType type=this.value.getType();
  this.value=this.value.resolve(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i]=this.cases[i].resolve(markers,context);
  }
  if (type == Type.BOOLEAN && this.caseCount >= 2) {
    this.exhaustive=true;
  }
  return this;
}
Program: 85144
Project: 85144
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  IType type=this.value.getType();
  int var=writer.registerLocal(type);
  this.value.writeExpression(writer);
  writer.writeVarInsn(type.getStoreOpcode(),var);
  Label elseLabel=new Label();
  Label endLabel=new Label();
  for (int i=0; i < this.caseCount; ) {
    this.cases[i].writeExpression(writer,var,elseLabel);
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
    writer.writeFrameLabel(elseLabel);
    if (++i < this.caseCount) {
      elseLabel=new Label();
    }
  }
  writer.writeFrameLabel(elseLabel);
  this.writeError(writer,type,type.getLoadOpcode(),var);
  writer.removeLocals(1);
  writer.writeFrameLabel(endLabel);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  int locals=writer.localCount();
  IType type=this.value.getType();
  int var=writer.registerLocal(type);
  this.value.writeExpression(writer);
  writer.writeVarInsn(type.getStoreOpcode(),var);
  Label elseLabel=new Label();
  Label endLabel=new Label();
  for (int i=0; i < this.caseCount; ) {
    this.cases[i].writeExpression(writer,var,elseLabel);
    writer.writeJumpInsn(Opcodes.GOTO,endLabel);
    writer.writeFrameLabel(elseLabel);
    if (++i < this.caseCount) {
      elseLabel=new Label();
    }
  }
  writer.writeFrameLabel(elseLabel);
  this.writeError(writer,type,type.getLoadOpcode(),var);
  writer.resetLocals(locals);
  writer.writeFrameLabel(endLabel);
}
Program: 85145
Project: 85145
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    this.cases[i].checkTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.value.checkTypes(markers,context);
  for (int i=0; i < this.caseCount; i++) {
    ICase c=this.cases[i];
    if (this.exhaustive) {
      markers.add(c.getPosition(),"String_Node_Str");
    }
    IPattern pattern=c.getPattern();
    if (pattern.getPatternType() == IPattern.WILDCARD) {
      if (c.getCondition() == null) {
        this.exhaustive=true;
      }
    }
 else     if (!pattern.isType(type)) {
      Marker marker=markers.create(pattern.getPosition(),"String_Node_Str");
      marker.addInfo("String_Node_Str" + pattern.getType());
      marker.addInfo("String_Node_Str" + type);
    }
    this.cases[i].checkTypes(markers,context);
  }
}
Program: 85147
Project: 85147
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=0;
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    var.index=writer.registerLocal(var.type);
    count++;
  }
  for (int i=0; i < this.valueCount; i++) {
    IValue v=this.values[i];
    if (this.labels != null) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeFrameLabel(l.target);
      }
    }
    v.writeStatement(writer);
  }
  if (count > 0 && (this.parent != null || !(this.context instanceof IMethod))) {
    writer.removeLocals(count);
    writer.writeFrameLabel(end);
  }
 else {
    writer.writeLabel(end);
  }
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=writer.localCount();
  for (int i=0; i < this.valueCount; i++) {
    IValue v=this.values[i];
    if (this.labels != null) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeFrameLabel(l.target);
      }
    }
    v.writeStatement(writer);
  }
  writer.resetLocals(count);
  writer.writeLabel(end);
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}
Program: 85148
Project: 85148
Buggy source:
@Override public int registerLocal(Object type){
  int index=this.localIndex;
  if (type == LONG || type == DOUBLE) {
    this.ensureLocals(index + 2);
    this.locals[index]=type;
    this.locals[index + 1]=type;
    this.localIndex+=2;
  }
 else {
    this.ensureLocals(index + 1);
    this.locals[index]=type;
    this.localIndex++;
  }
  return index;
}

Fixed version (ground truth):
@Override public int registerLocal(Object type){
  int index=this.localIndex;
  if (type == LONG || type == DOUBLE) {
    this.ensureLocals(index + 2);
    this.locals[index]=type;
    this.locals[index + 1]=TOP;
    this.localIndex+=2;
  }
 else {
    this.ensureLocals(index + 1);
    this.locals[index]=type;
    this.localIndex++;
  }
  return index;
}
Program: 85149
Project: 85149
Buggy source:
@Override public void removeLocals(int count){
  for (int i=0; i < count; i++) {
    this.localCount--;
    Object o=this.locals[--this.localIndex];
    if (o == LONG || o == DOUBLE) {
      this.localIndex--;
    }
  }
}

Fixed version (ground truth):
@Override public void removeLocals(int count){
  this.localCount-=count;
  this.localIndex-=count;
}
Program: 85150
Project: 85150
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (ParserUtil.isCloseBracket(type)) {
    pm.popParser(true);
    return;
  }
  if (this.mode == 0) {
    if (token.next().type() == Tokens.COLON) {
      this.label=token.value();
      pm.skip();
      return;
    }
    this.mode=1;
    pm.pushParser(new ExpressionParser(this),true);
    return;
  }
  if (this.mode == 1) {
    if (type == Tokens.COMMA) {
      this.valueList.setArray(true);
      this.mode=0;
      return;
    }
    if (type == Tokens.SEMICOLON) {
      this.mode=0;
      return;
    }
    if (token.prev().type() == Tokens.CLOSE_CURLY_BRACKET) {
      pm.pushParser(new ExpressionParser(this),true);
      return;
    }
    throw new SyntaxError(token,"String_Node_Str" + token.value() + "String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
  if (ParserUtil.isCloseBracket(type)) {
    pm.popParser(true);
    return;
  }
  if (this.mode == 0) {
    if (token.next().type() == Tokens.COLON) {
      this.label=token.value();
      pm.skip();
      return;
    }
    this.mode=1;
    pm.pushParser(new ExpressionParser(this),true);
    return;
  }
  if (this.mode == 1) {
    if (type == Tokens.COMMA) {
      this.valueList.setArray(true);
      this.mode=0;
      return;
    }
    if (type == Tokens.SEMICOLON) {
      this.mode=0;
      return;
    }
    if (token.prev().type() == Tokens.CLOSE_CURLY_BRACKET) {
      pm.pushParser(new ExpressionParser(this),true);
      return;
    }
    throw new SyntaxError(token,"String_Node_Str");
  }
}
Program: 85151
Project: 85151
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 == Tokens.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CONDITION_END) {
    this.mode=THEN;
    if (type == Tokens.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (ParserUtil.isTerminator(type)) {
    if (!token.isInferred()) {
      pm.popParser(true);
    }
    return;
  }
  if (this.mode == THEN) {
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=ELSE;
    return;
  }
  if (this.mode == ELSE) {
    if (type == Tokens.ELSE) {
      pm.pushParser(new ExpressionParser(this));
      this.mode=-1;
      return;
    }
    pm.popParser(true);
  }
}

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 == Tokens.OPEN_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (this.mode == CONDITION_END) {
    this.mode=THEN;
    if (type == Tokens.CLOSE_PARENTHESIS) {
      return;
    }
    throw new SyntaxError(token,"String_Node_Str",true);
  }
  if (ParserUtil.isTerminator(type)) {
    if (!token.isInferred()) {
      pm.popParser(true);
    }
    return;
  }
  if (this.mode == THEN) {
    pm.pushParser(new ExpressionParser(this),true);
    this.mode=ELSE;
    return;
  }
  if (this.mode == ELSE) {
    if (type == Tokens.ELSE) {
      pm.pushParser(new ExpressionParser(this));
      this.mode=-1;
      return;
    }
    pm.popParser(true);
    return;
  }
}
Program: 85153
Project: 85153
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (this.overrideMethod == null) {
      if ((this.modifiers & Modifiers.OVERRIDE) != 0) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
    }
 else     if (!this.isConstructor) {
      if ((this.modifiers & Modifiers.OVERRIDE) == 0) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
 else       if (this.overrideMethod.hasModifier(Modifiers.FINAL)) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
 else {
        IType type=this.overrideMethod.getType();
        if (type.isSuperTypeOf(this.type)) {
          Marker marker=markers.create(this.position,"String_Node_Str",this.name);
          marker.addInfo("String_Node_Str" + this.type);
          marker.addInfo("String_Node_Str" + type);
        }
      }
    }
  }
  super.check(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].check(markers,context);
  }
  if (this.value != null) {
    if (this.isConstructor) {
      if (!this.value.isType(Type.VOID)) {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + this.value.getType());
      }
    }
    this.value.check(markers,context);
  }
 else   if (this.isStatic()) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0 && !this.theClass.isAbstract()) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  if ((this.modifiers & Modifiers.STATIC) == 0) {
    if (this.overrideMethod == null) {
      if ((this.modifiers & Modifiers.OVERRIDE) != 0) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
    }
 else     if (!this.isConstructor) {
      if ((this.modifiers & Modifiers.OVERRIDE) == 0) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
 else       if (this.overrideMethod.hasModifier(Modifiers.FINAL)) {
        markers.add(this.position,"String_Node_Str",this.name);
      }
 else {
        IType type=this.overrideMethod.getType();
        if (type.isSuperTypeOf(this.type)) {
          Marker marker=markers.create(this.position,"String_Node_Str",this.name);
          marker.addInfo("String_Node_Str" + this.type);
          marker.addInfo("String_Node_Str" + type);
        }
      }
    }
  }
  super.check(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].check(markers,context);
  }
  if (this.value != null) {
    this.value.check(markers,this);
  }
 else   if (this.isStatic()) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0 && !this.theClass.isAbstract()) {
    markers.add(this.position,"String_Node_Str",this.name);
  }
}
Program: 85154
Project: 85154
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    IValue value1=this.value.withType(this.type);
    if (value1 == null) {
      Marker marker=markers.create(this.position,"String_Node_Str",this.name);
      marker.addInfo("String_Node_Str" + this.type);
      marker.addInfo("String_Node_Str" + this.value.getType());
    }
 else {
      this.value=value1;
    }
    this.value.checkTypes(markers,context);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  super.checkTypes(markers,context);
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].checkTypes(markers,context);
  }
  if (this.value != null) {
    if (this.isConstructor) {
      IValue value1=this.value.withType(Type.VOID);
      if (value1 == null) {
        Marker marker=markers.create(this.position,"String_Node_Str");
        marker.addInfo("String_Node_Str" + this.value.getType());
      }
 else {
        this.value=value1;
      }
    }
 else {
      IValue value1=this.value.withType(this.type);
      if (value1 == null) {
        Marker marker=markers.create(this.position,"String_Node_Str",this.name);
        marker.addInfo("String_Node_Str" + this.type);
        marker.addInfo("String_Node_Str" + this.value.getType());
      }
 else {
        this.value=value1;
      }
    }
    this.value.checkTypes(markers,this);
  }
 else   if ((this.modifiers & Modifiers.ABSTRACT) == 0) {
    this.modifiers|=Modifiers.ABSTRACT;
  }
}
Program: 85155
Project: 85155
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeFrameLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  writer.resetLocals(count);
  writer.writeLabel(end);
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=writer.localCount();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeFrameLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  if (!(this.context instanceof IMethod)) {
    writer.resetLocals(count);
  }
  writer.writeLabel(end);
  for (  Entry<String,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.qualifiedName,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}
Program: 85156
Project: 85156
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].check(markers,context);
  }
  this.context=null;
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].check(markers,context);
  }
}
Program: 85157
Project: 85157
Buggy source:
public default Object getFrameType(){
  StringBuilder buffer=new StringBuilder();
  this.appendExtendedName(buffer);
  return buffer.toString();
}

Fixed version (ground truth):
public default Object getFrameType(){
  return this.getInternalName();
}
Program: 85158
Project: 85158
Buggy source:
@Override public void appendExtendedName(StringBuilder buffer){
  for (int i=0; i < this.arrayDimensions; i++) {
    buffer.append('[');
  }
  buffer.append('L').append(this.getInternalName()).append(';');
}

Fixed version (ground truth):
@Override public void appendExtendedName(StringBuilder buffer){
  for (int i=0; i < this.arrayDimensions; i++) {
    buffer.append('[');
  }
  buffer.append('L').append(this.theClass == null ? ClassFormat.packageToInternal(this.qualifiedName) : this.theClass.getInternalName()).append(';');
}
Program: 85159
Project: 85159
Buggy source:
@Override public String getInternalName(){
  return this.theClass == null ? ClassFormat.packageToInternal(this.qualifiedName) : this.theClass.getInternalName();
}

Fixed version (ground truth):
@Override public String getInternalName(){
  if (this.arrayDimensions > 0) {
    StringBuilder buf=new StringBuilder();
    this.appendExtendedName(buf);
    return buf.toString();
  }
  return this.theClass == null ? ClassFormat.packageToInternal(this.qualifiedName) : this.theClass.getInternalName();
}
Program: 85161
Project: 85161
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.lowerBound != null) {
    this.lowerBound=this.lowerBound.resolve(markers,context);
  }
  if (this.upperBoundCount > 0) {
    IType type=this.upperBounds[0];
    IClass iclass=type.getTheClass();
    if (iclass != null) {
      if (iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
        if (++this.upperBoundCount > this.upperBounds.length) {
          IType[] temp=new IType[this.upperBoundCount];
          temp[0]=Type.OBJECT;
          System.arraycopy(this.upperBounds,0,temp,1,this.upperBoundCount - 1);
          this.upperBounds=temp;
        }
 else {
          System.arraycopy(this.upperBounds,0,this.upperBounds,1,this.upperBoundCount - 1);
          this.upperBounds[0]=Type.OBJECT;
        }
      }
    }
    for (int i=1; i < this.upperBoundCount; i++) {
      type=this.upperBounds[i];
      iclass=type.getTheClass();
      if (iclass != null && !iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
        System.arraycopy(this.upperBounds,i + 1,this.upperBounds,i,this.upperBoundCount - i - 1);
        this.upperBoundCount--;
        i--;
      }
    }
  }
  this.captureClass=new CaptureClass(this,this.upperBounds,this.upperBoundCount,this.lowerBound);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.lowerBound != null) {
    this.lowerBound=this.lowerBound.resolve(markers,context);
  }
  if (this.upperBoundCount > 0) {
    IType type=this.upperBounds[0]=this.upperBounds[0].resolve(markers,context);
    IClass iclass=type.getTheClass();
    if (iclass != null) {
      if (iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
        if (++this.upperBoundCount > this.upperBounds.length) {
          IType[] temp=new IType[this.upperBoundCount];
          temp[0]=Type.OBJECT;
          System.arraycopy(this.upperBounds,0,temp,1,this.upperBoundCount - 1);
          this.upperBounds=temp;
        }
 else {
          System.arraycopy(this.upperBounds,0,this.upperBounds,1,this.upperBoundCount - 1);
          this.upperBounds[0]=Type.OBJECT;
        }
      }
    }
    for (int i=1; i < this.upperBoundCount; i++) {
      type=this.upperBounds[i]=this.upperBounds[i].resolve(markers,context);
      iclass=type.getTheClass();
      if (iclass != null && !iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
        System.arraycopy(this.upperBounds,i + 1,this.upperBounds,i,this.upperBoundCount - i - 1);
        this.upperBoundCount--;
        i--;
      }
    }
  }
  this.captureClass=new CaptureClass(this,this.upperBounds,this.upperBoundCount,this.lowerBound);
}
Program: 85164
Project: 85164
Buggy source:
@Override public void write(ClassWriter writer){
  boolean instance=this.thisType != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriterImpl(writer,writer.visitMethod(modifiers,this.getName(),this.getLambdaDescriptor(),null,null));
  int[] prevIndex=null;
  if (instance) {
    mw.registerLocal(this.thisType);
  }
  if (this.capturedFieldCount > 0) {
    prevIndex=new int[this.capturedFieldCount];
    for (int i=0; i < this.capturedFieldCount; i++) {
      IVariable var=this.capturedFields[i];
      prevIndex[i]=var.getIndex();
      var.setIndex(mw.registerParameter(var.getQualifiedName(),var.getType()));
    }
  }
  for (int i=0; i < this.parameterCount; i++) {
    LambdaParameter param=this.parameters[i];
    param.index=mw.registerParameter(param.qualifiedName,param.type);
  }
  mw.begin();
  this.value.writeExpression(mw);
  mw.end(this.method.getType());
  for (int i=0; i < this.parameterCount; i++) {
    IVariable var=this.capturedFields[i];
    var.setIndex(prevIndex[i]);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer){
  boolean instance=this.thisType != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriterImpl(writer,writer.visitMethod(modifiers,this.getName(),this.getLambdaDescriptor(),null,null));
  int[] prevIndex=null;
  if (instance) {
    mw.registerLocal(this.thisType);
  }
  if (this.capturedFieldCount > 0) {
    prevIndex=new int[this.capturedFieldCount];
    for (int i=0; i < this.capturedFieldCount; i++) {
      IVariable var=this.capturedFields[i];
      prevIndex[i]=var.getIndex();
      var.setIndex(mw.registerParameter(var.getQualifiedName(),var.getType()));
    }
  }
  for (int i=0; i < this.parameterCount; i++) {
    LambdaParameter param=this.parameters[i];
    param.index=mw.registerParameter(param.qualifiedName,param.type);
  }
  mw.begin();
  this.value.writeExpression(mw);
  mw.end(this.method.getType());
  for (int i=0; i < this.capturedFieldCount; i++) {
    IVariable var=this.capturedFields[i];
    var.setIndex(prevIndex[i]);
  }
}
Program: 85165
Project: 85165
Buggy source:
@Override public boolean processAnnotation(Annotation annotation){
  String name=annotation.type.fullName;
  if ("String_Node_Str".equals(name)) {
    this.modifiers|=Modifiers.BYREF;
    return true;
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean processAnnotation(Annotation annotation){
  String name=annotation.type.fullName;
  if ("String_Node_Str".equals(name)) {
    this.modifiers|=Modifiers.VAR;
    return true;
  }
  if ("String_Node_Str".equals(name)) {
    this.modifiers|=Modifiers.LAZY;
    return true;
  }
  return false;
}
Program: 85166
Project: 85166
Buggy source:
public void write(MethodWriter writer){
  this.index=writer.registerParameter(this.name,this.type);
  if ((this.modifiers & Modifiers.BYREF) != 0) {
    writer.addParameterAnnotation(this.index,"String_Node_Str",true);
  }
  for (  Annotation a : this.annotations) {
    a.write(writer,this.index);
  }
}

Fixed version (ground truth):
public void write(MethodWriter writer){
  this.index=writer.registerParameter(this.name,this.type);
  if ((this.modifiers & Modifiers.VAR) != 0) {
    writer.addParameterAnnotation(this.index,"String_Node_Str",true);
  }
  for (  Annotation a : this.annotations) {
    a.write(writer,this.index);
  }
}
Program: 85167
Project: 85167
Buggy source:
@Override public IValue resolve(List<Marker> markers,IContext context){
  if (this.isArray) {
    IValue[] values=new IValue[this.valueCount];
    System.arraycopy(this.values,0,values,0,this.valueCount);
    return new ValueList(this.position,values,this.requiredType,this.elementType).resolve(markers,context);
  }
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    IValue v1=this.values[i];
    IValue v2=v1.resolve(markers,this);
    if (v1 != v2) {
      this.values[i]=v2;
    }
    if (v2.getValueType() == IValue.VARIABLE) {
      FieldInitializer fi=(FieldInitializer)v2;
      Variable var=fi.variable;
      this.variables.put(var.qualifiedName,var);
    }
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(List<Marker> markers,IContext context){
  if (this.isArray) {
    IValue[] values=new IValue[this.valueCount];
    System.arraycopy(this.values,0,values,0,this.valueCount);
    return new ValueList(this.position,values,this.requiredType,this.elementType).resolve(markers,context);
  }
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    IValue v1=this.values[i];
    IValue v2=v1.resolve(markers,this);
    if (v1 != v2) {
      this.values[i]=v2;
    }
    if (v2.getValueType() == IValue.VARIABLE) {
      FieldInitializer fi=(FieldInitializer)v2;
      Variable var=fi.variable;
      this.variables.put(var.qualifiedName,var);
    }
  }
  this.context=null;
  return this;
}
Program: 85168
Project: 85168
Buggy source:
@Override public void check(List<Marker> markers,IContext context){
  if (this.isArray) {
    super.check(markers,context);
  }
 else {
    IType type=this.requiredType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v=this.values[i];
      v.check(markers,this);
      if (v.getValueType() == RETURN && v.withType(type) == null) {
        Marker marker=Markers.create(v.getPosition(),"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
        marker.addInfo("String_Node_Str" + v.getType());
        markers.add(marker);
      }
    }
  }
}

Fixed version (ground truth):
@Override public void check(List<Marker> markers,IContext context){
  if (this.isArray) {
    super.check(markers,context);
  }
 else {
    this.context=context;
    IType type=this.requiredType;
    for (int i=0; i < this.valueCount; i++) {
      IValue v=this.values[i];
      v.check(markers,this);
      if (v.getValueType() == RETURN && v.withType(type) == null) {
        Marker marker=Markers.create(v.getPosition(),"String_Node_Str");
        marker.addInfo("String_Node_Str" + type);
        marker.addInfo("String_Node_Str" + v.getType());
        markers.add(marker);
      }
    }
    this.context=null;
  }
}
Program: 85169
Project: 85169
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  if (this.isArray) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].resolveTypes(markers,context);
    }
    return;
  }
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    IValue v=this.values[i];
    if (v.isStatement()) {
      ((IStatement)v).setParent(this);
    }
    v.resolveTypes(markers,this);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  if (this.isArray) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].resolveTypes(markers,context);
    }
    return;
  }
  this.context=context;
  for (int i=0; i < this.valueCount; i++) {
    IValue v=this.values[i];
    if (v.isStatement()) {
      ((IStatement)v).setParent(this);
    }
    v.resolveTypes(markers,this);
  }
  this.context=null;
}
Program: 85171
Project: 85171
Buggy source:
@Override public void write(ClassWriter writer){
  this.name="String_Node_Str" + this.index;
  this.desc=this.getLambdaDescriptor();
  boolean instance=this.thisType != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriter(writer,writer.visitMethod(modifiers,this.name,this.desc,null,null));
  int[] prevIndex=null;
  if (instance) {
    mw.addLocal(this.thisType);
  }
  if (this.capturedFieldCount > 0) {
    prevIndex=new int[this.capturedFieldCount];
    for (int i=0; i < this.capturedFieldCount; i++) {
      IVariable var=this.capturedFields[i];
      prevIndex[i]=var.getIndex();
      var.setIndex(mw.visitParameter(var.getQualifiedName(),var.getType()));
    }
  }
  for (int i=0; i < this.parameterCount; i++) {
    LambdaParameter param=this.parameters[i];
    param.index=mw.visitParameter(param.qualifiedName,param.type);
  }
  mw.visitCode();
  this.value.writeExpression(mw);
  mw.visitEnd(this.method.getType());
  for (int i=0; i < this.parameterCount; i++) {
    IVariable var=this.capturedFields[i];
    var.setIndex(prevIndex[i]);
  }
}

Fixed version (ground truth):
@Override public void write(ClassWriter writer){
  boolean instance=this.thisType != null;
  int modifiers=instance ? Modifiers.PRIVATE | Modifiers.SYNTHETIC : Modifiers.PRIVATE | Modifiers.STATIC | Modifiers.SYNTHETIC;
  MethodWriter mw=new MethodWriter(writer,writer.visitMethod(modifiers,this.name,this.desc,null,null));
  int[] prevIndex=null;
  if (instance) {
    mw.addLocal(this.thisType);
  }
  if (this.capturedFieldCount > 0) {
    prevIndex=new int[this.capturedFieldCount];
    for (int i=0; i < this.capturedFieldCount; i++) {
      IVariable var=this.capturedFields[i];
      prevIndex[i]=var.getIndex();
      var.setIndex(mw.visitParameter(var.getQualifiedName(),var.getType()));
    }
  }
  for (int i=0; i < this.parameterCount; i++) {
    LambdaParameter param=this.parameters[i];
    param.index=mw.visitParameter(param.qualifiedName,param.type);
  }
  mw.visitCode();
  this.value.writeExpression(mw);
  mw.visitEnd(this.method.getType());
  for (int i=0; i < this.parameterCount; i++) {
    IVariable var=this.capturedFields[i];
    var.setIndex(prevIndex[i]);
  }
}
Program: 85172
Project: 85172
Buggy source:
@Override public void check(List<Marker> markers,IContext context){
  if (this.method != null) {
    if (this.method.hasTypeVariables()) {
      this.returnType=this.method.getType(this);
      for (int i=0; i < this.parameterCount; i++) {
        LambdaParameter param=this.parameters[i];
        param.baseType=method.getParameter(i).type;
        param.type=param.type.getConcreteType(this);
      }
    }
 else {
      this.returnType=this.method.getType();
    }
  }
 else {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
  this.context=context;
  this.value=this.value.resolve(markers,this);
  this.value.check(markers,context);
}

Fixed version (ground truth):
@Override public void check(List<Marker> markers,IContext context){
  if (this.method != null) {
    if (this.method.hasTypeVariables()) {
      this.returnType=this.method.getType(this);
      for (int i=0; i < this.parameterCount; i++) {
        LambdaParameter param=this.parameters[i];
        param.baseType=method.getParameter(i).type;
        param.type=param.type.getConcreteType(this);
      }
    }
 else {
      this.returnType=this.method.getType();
    }
  }
 else {
    markers.add(Markers.create(this.position,"String_Node_Str"));
  }
  this.context=context;
  this.value=this.value.resolve(markers,this);
  this.value.check(markers,context);
  this.name="String_Node_Str" + this.index;
  this.desc=this.getLambdaDescriptor();
}
Program: 85173
Project: 85173
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  for (  IValue v : this.values) {
    v.writeStatement(writer);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].writeStatement(writer);
  }
}
Program: 85174
Project: 85174
Buggy source:
@Override public void check(List<Marker> markers,IContext context){
  for (  IValue v : this.values) {
    v.check(markers,context);
  }
}

Fixed version (ground truth):
@Override public void check(List<Marker> markers,IContext context){
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].check(markers,context);
  }
}
Program: 85175
Project: 85175
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  TupleType t=this.tupleType;
  writer.visitTypeInsn(Opcodes.NEW,t);
  writer.visitInsn(Opcodes.DUP);
  for (  IValue v : this.values) {
    v.writeExpression(writer);
  }
  String owner=t.getInternalName();
  String desc=t.getConstructorDescriptor();
  writer.visitMethodInsn(Opcodes.INVOKESPECIAL,owner,"String_Node_Str",desc,false,this.valueCount + 1,t);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
  TupleType t=this.tupleType;
  writer.visitTypeInsn(Opcodes.NEW,t);
  writer.visitInsn(Opcodes.DUP);
  for (int i=0; i < this.valueCount; i++) {
    this.values[i].writeExpression(writer);
  }
  String owner=t.getInternalName();
  String desc=t.getConstructorDescriptor();
  writer.visitMethodInsn(Opcodes.INVOKESPECIAL,owner,"String_Node_Str",desc,false,this.valueCount + 1,t);
}
Program: 85176
Project: 85176
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  TupleType type=new TupleType();
  for (  IValue v : this.values) {
    v.resolveTypes(markers,context);
    type.addType(v.getType());
  }
  type.getTheClass();
  this.tupleType=type;
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  TupleType type=new TupleType();
  for (int i=0; i < this.valueCount; i++) {
    IValue v=this.values[i];
    v.resolveTypes(markers,context);
    type.addType(v.getType());
  }
  type.getTheClass();
  this.tupleType=type;
}
Program: 85177
Project: 85177
Buggy source:
@Override public IClass resolveClass(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  if (this.generics != null) {
    for (    ITypeVariable var : this.generics) {
      if (var.isName(name)) {
        return var.getCaptureClass();
      }
    }
  }
  IClass clazz=this.body.getClass(name);
  if (clazz != null) {
    return clazz;
  }
  return null;
}

Fixed version (ground truth):
@Override public IClass resolveClass(String name){
  if (!this.typesResolved) {
    this.resolveTypes(null,Package.rootPackage);
  }
  for (int i=0; i < this.genericCount; i++) {
    ITypeVariable var=this.generics[i];
    if (var.isName(name)) {
      return var.getCaptureClass();
    }
  }
  IClass clazz=this.body.getClass(name);
  if (clazz != null) {
    return clazz;
  }
  return null;
}
Program: 85178
Project: 85178
Buggy source:
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.typesResolved=true;
  if (this.generics != null) {
    GenericType type=new GenericType(this);
    for (    ITypeVariable v : this.generics) {
      v.resolveTypes(markers,context);
      type.addType(new WildcardType(null,0,v.getCaptureClass()));
    }
    this.type=type;
  }
  if (this.superType != null) {
    if (this.superType.isName("String_Node_Str")) {
      this.superType=null;
    }
 else {
      this.superType=this.superType.resolve(markers,context);
    }
  }
  for (ListIterator<IType> iterator=this.interfaces.listIterator(); iterator.hasNext(); ) {
    IType i1=iterator.next();
    IType i2=i1.resolve(markers,context);
    if (i1 != i2) {
      iterator.set(i2);
    }
  }
  for (int i=0; i < this.annotationCount; i++) {
    this.annotations[i].resolveTypes(markers,context);
  }
  this.body.resolveTypes(markers,this);
  if (this.outerType != null) {
    this.outerClass=this.outerType.resolve(markers,context).getTheClass();
  }
  if (this.innerTypes != null) {
    for (    IType t : this.innerTypes) {
      IClass iclass=t.resolve(markers,context).getTheClass();
      this.body.addClass(iclass);
    }
    this.innerTypes=null;
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(List<Marker> markers,IContext context){
  this.typesResolved=true;
  if (this.genericCount > 0) {
    GenericType type=new GenericType(this);
    for (int i=0; i < this.genericCount; i++) {
      ITypeVariable var=this.generics[i];
      var.resolveTypes(markers,context);
      type.addType(new WildcardType(null,0,var.getCaptureClass()));
    }
    this.type=type;
  }
  if (this.superType != null) {
    if (this.superType.isName("String_Node_Str")) {
      this.superType=null;
    }
 else {
      this.superType=this.superType.resolve(markers,context);
    }
  }
  for (ListIterator<IType> iterator=this.interfaces.listIterator(); iterator.hasNext(); ) {
    IType i1=iterator.next();
    IType i2=i1.resolve(markers,context);
    if (i1 != i2) {
      iterator.set(i2);
    }
  }
  for (int i=0; i < this.annotationCount; i++) {
    this.annotations[i].resolveTypes(markers,context);
  }
  this.body.resolveTypes(markers,this);
  if (this.outerType != null) {
    this.outerClass=this.outerType.resolve(markers,context).getTheClass();
  }
  if (this.innerTypes != null) {
    for (    IType t : this.innerTypes) {
      IClass iclass=t.resolve(markers,context).getTheClass();
      this.body.addClass(iclass);
    }
    this.innerTypes=null;
  }
}