nus-yam/ex-repair huggingface dataset:
Program: 84205
Project: 84205
Buggy source:
public final void parse(TokenIterator tokens){
  this.tokens=tokens;
  IToken token=null;
  while (!this.hasStopped) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      if (!this.tokens.hasNext()) {
        break;
      }
      token=tokens.next();
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    if (this.parser == null) {
      if (token != null && !token.isInferred()) {
        this.report(Markers.syntaxError(token,"String_Node_Str",token));
      }
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      this.report(Markers.parserError(token,ex));
    }
  }
  this.parseRemaining(token);
}

Fixed version (ground truth):
public final void parse(TokenIterator tokens){
  this.tokens=tokens;
  IToken token=null;
  while (!this.hasStopped) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      if (!this.tokens.hasNext()) {
        break;
      }
      token=tokens.next();
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    if (this.parser == null) {
      if (token != null && !token.isInferred()) {
        this.report(Markers.syntaxError(token,"String_Node_Str",token));
      }
      continue;
    }
    this.tryParse(token,this.parser);
  }
  this.parseRemaining(token);
}
Program: 84206
Project: 84206
Buggy source:
@Override public boolean isResolved(){
  return this.value.isResolved();
}

Fixed version (ground truth):
@Override public boolean isResolved(){
  return this.value == null || this.value.isResolved();
}
Program: 84208
Project: 84208
Buggy source:
@Override public IPattern withType(IType type,MarkerList markers){
  IClass tupleClass=TupleType.getTupleClass(this.patternCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  this.tupleType=type;
  for (int i=0; i < this.patternCount; i++) {
    IType elementType=type.resolveTypeSafely(tupleClass.getTypeParameter(i));
    IPattern pattern=this.patterns[i];
    IPattern typedPattern=pattern.withType(elementType,markers);
    if (typedPattern == null) {
      Marker m=Markers.semantic(pattern.getPosition(),"String_Node_Str");
      m.addInfo(Markers.getSemantic("String_Node_Str",pattern.getType()));
      m.addInfo(Markers.getSemantic("String_Node_Str",elementType));
      markers.add(m);
    }
 else {
      this.patterns[i]=typedPattern;
    }
  }
  return this;
}

Fixed version (ground truth):
@Override public IPattern withType(IType type,MarkerList markers){
  IClass tupleClass=TupleType.getTupleClass(this.patternCount);
  if (tupleClass == null || !tupleClass.isSubTypeOf(type)) {
    return null;
  }
  this.tupleType=type;
  for (int i=0; i < this.patternCount; i++) {
    IType elementType=type.resolveTypeSafely(tupleClass.getTypeParameter(i));
    IPattern pattern=this.patterns[i];
    IPattern typedPattern=pattern.withType(elementType,markers);
    if (typedPattern == null) {
      Marker m=Markers.semantic(pattern.getPosition(),"String_Node_Str");
      m.addInfo(Markers.getSemantic("String_Node_Str",pattern.getType()));
      m.addInfo(Markers.getSemantic("String_Node_Str",elementType));
      markers.add(m);
    }
 else {
      this.patterns[i]=typedPattern;
    }
  }
  return this;
}
Program: 84209
Project: 84209
Buggy source:
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  if (this.valueCount == 1) {
    return this.values[0].withType(type,typeContext,markers,context);
  }
  IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralConversion(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  IClass tupleClass=TupleType.getTupleClass(this.valueCount);
  if (!tupleClass.isSubTypeOf(type)) {
    return null;
  }
  IClass iclass=type.getTheClass();
  for (int i=0; i < this.valueCount; i++) {
    IType elementType=iclass == dyvil.tools.compiler.ast.type.builtin.Types.OBJECT_CLASS ? dyvil.tools.compiler.ast.type.builtin.Types.ANY : type.resolveTypeSafely(iclass.getTypeParameter(i));
    IValue value=this.values[i];
    IValue value1=IType.convertValue(value,elementType,typeContext,markers,context);
    if (value1 == null) {
      Marker m=Markers.semantic(value.getPosition(),"String_Node_Str");
      m.addInfo(Markers.getSemantic("String_Node_Str",value.getType()));
      m.addInfo(Markers.getSemantic("String_Node_Str",elementType.getConcreteType(typeContext)));
      markers.add(m);
    }
 else {
      this.values[i]=value=value1;
    }
  }
  this.tupleType=null;
  this.tupleType=this.getType();
  return this;
}

Fixed version (ground truth):
@Override public IValue withType(IType type,ITypeContext typeContext,MarkerList markers,IContext context){
  final IAnnotation annotation=type.getTheClass().getAnnotation(Types.TUPLE_CONVERTIBLE);
  if (annotation != null) {
    return new LiteralConversion(this,annotation,new ArgumentList(this.values,this.valueCount)).withType(type,typeContext,markers,context);
  }
  if (!type.isSuperTypeOf(this.getType())) {
    return null;
  }
  final IClass iclass=type.getTheClass();
  for (int i=0; i < this.valueCount; i++) {
    final IType elementType=iclass == dyvil.tools.compiler.ast.type.builtin.Types.OBJECT_CLASS ? dyvil.tools.compiler.ast.type.builtin.Types.ANY : type.resolveTypeSafely(iclass.getTypeParameter(i));
    final IValue value=this.values[i];
    final IValue typedValue=IType.convertValue(value,elementType,typeContext,markers,context);
    if (typedValue != null) {
      this.values[i]=typedValue;
    }
 else     if (value.isResolved()) {
      final Marker marker=Markers.semantic(value.getPosition(),"String_Node_Str");
      marker.addInfo(Markers.getSemantic("String_Node_Str",value.getType()));
      marker.addInfo(Markers.getSemantic("String_Node_Str",elementType.getConcreteType(typeContext)));
      markers.add(marker);
    }
  }
  return this;
}
Program: 84210
Project: 84210
Buggy source:
@Override public IType getSimpleRefType(){
  if (this.simpleRefType != null) {
    return this.simpleRefType;
  }
  final String className="String_Node_Str" + this.classPrefix() + "String_Node_Str";
  return this.simpleRefType=new ClassType(Package.dyvilRefSimple.resolveClass(className));
}

Fixed version (ground truth):
@Override public IType getSimpleRefType(){
  if (this.simpleRefType != null) {
    return this.simpleRefType;
  }
  final String className="String_Node_Str" + this.getTypePrefix() + "String_Node_Str";
  return this.simpleRefType=new ClassType(Package.dyvilRefSimple.resolveClass(className));
}
Program: 84211
Project: 84211
Buggy source:
@Override public IClass getArrayClass(){
  IClass iclass=this.arrayClass;
  if (iclass == null) {
    String className=this.classPrefix() + "String_Node_Str";
    return this.arrayClass=Package.dyvilArray.resolveClass(className);
  }
  return iclass;
}

Fixed version (ground truth):
@Override public IClass getArrayClass(){
  IClass iclass=this.arrayClass;
  if (iclass == null) {
    final String className=this.getTypePrefix() + "String_Node_Str";
    return this.arrayClass=Package.dyvilArray.resolveClass(className);
  }
  return iclass;
}
Program: 84212
Project: 84212
Buggy source:
@Override public IClass getRefClass(){
  if (this.refClass != null) {
    return this.refClass;
  }
  final String className=this.classPrefix() + "String_Node_Str";
  return this.refClass=Package.dyvilRef.resolveClass(className);
}

Fixed version (ground truth):
@Override public IClass getRefClass(){
  if (this.refClass != null) {
    return this.refClass;
  }
  final String className=this.getTypePrefix() + "String_Node_Str";
  return this.refClass=Package.dyvilRef.resolveClass(className);
}
Program: 84213
Project: 84213
Buggy source:
public static String getInternalRef(IType type,String prefix){
  return "String_Node_Str" + prefix + getTypeRefKeyword(type)+ "String_Node_Str";
}

Fixed version (ground truth):
public static String getInternalRef(IType type,String prefix){
  return "String_Node_Str" + prefix + type.getTypePrefix()+ "String_Node_Str";
}
Program: 84214
Project: 84214
Buggy source:
public static String getReferenceFactoryName(IType type,String prefix){
  return "String_Node_Str" + prefix + getTypeRefKeyword(type)+ "String_Node_Str";
}

Fixed version (ground truth):
public static String getReferenceFactoryName(IType type,String prefix){
  return "String_Node_Str" + prefix + type.getTypePrefix()+ "String_Node_Str";
}
Program: 84215
Project: 84215
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  final Name name=this.type.getName();
  final IDataMember field=context.resolveField(name);
  if (field != null) {
    final FieldAccess fieldAccess=new FieldAccess(this.position);
    fieldAccess.name=name;
    fieldAccess.field=field;
    return fieldAccess;
  }
  final IMethod method=IContext.resolveMethod(context,null,name,EmptyArguments.INSTANCE);
  if (method != null) {
    final MethodCall methodCall=new MethodCall(this.position);
    methodCall.name=name;
    methodCall.method=method;
    methodCall.dotless=true;
    methodCall.arguments=EmptyArguments.INSTANCE;
    return methodCall;
  }
  if (!this.type.isResolved()) {
    markers.add(Markers.semantic(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString()));
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  final Name name=this.type.getName();
  final IDataMember field=context.resolveField(name);
  if (field != null) {
    final FieldAccess fieldAccess=new FieldAccess(this.position);
    fieldAccess.name=name;
    fieldAccess.field=field;
    return fieldAccess;
  }
  final IMethod method=IContext.resolveMethod(context,null,name,EmptyArguments.INSTANCE);
  if (method != null) {
    final MethodCall methodCall=new MethodCall(this.position);
    methodCall.name=name;
    methodCall.method=method;
    methodCall.dotless=true;
    methodCall.arguments=EmptyArguments.INSTANCE;
    return methodCall;
  }
  return this;
}
Program: 84216
Project: 84216
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  if (iclass.hasModifier(Modifiers.OBJECT_CLASS)) {
    return;
  }
  markers.add(Markers.semantic(this.position,"String_Node_Str",this.type.toString()));
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  if (!this.type.isResolved()) {
    return;
  }
  final IClass iclass=this.type.getTheClass();
  if (iclass != null && iclass.hasModifier(Modifiers.OBJECT_CLASS)) {
    return;
  }
  markers.add(Markers.semantic(this.position,"String_Node_Str",this.type.toString()));
}
Program: 84217
Project: 84217
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.TYPE);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.TYPE);
  if (!this.type.isResolved()) {
    markers.add(Markers.semantic(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString()));
  }
}
Program: 84218
Project: 84218
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  final Name name=this.type.getName();
  final IDataMember field=context.resolveField(name);
  if (field != null) {
    final FieldAccess fieldAccess=new FieldAccess(this.position);
    fieldAccess.name=name;
    fieldAccess.field=field;
    return fieldAccess;
  }
  final IMethod method=IContext.resolveMethod(context,null,name,EmptyArguments.INSTANCE);
  if (method != null) {
    final MethodCall methodCall=new MethodCall(this.position);
    methodCall.name=name;
    methodCall.method=method;
    methodCall.dotless=true;
    methodCall.arguments=EmptyArguments.INSTANCE;
    return methodCall;
  }
  if (!this.type.isResolved()) {
    markers.add(Markers.semantic(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString()));
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  this.type.resolve(markers,context);
  final Name name=this.type.getName();
  final IDataMember field=context.resolveField(name);
  if (field != null) {
    final FieldAccess fieldAccess=new FieldAccess(this.position);
    fieldAccess.name=name;
    fieldAccess.field=field;
    return fieldAccess;
  }
  final IMethod method=IContext.resolveMethod(context,null,name,EmptyArguments.INSTANCE);
  if (method != null) {
    final MethodCall methodCall=new MethodCall(this.position);
    methodCall.name=name;
    methodCall.method=method;
    methodCall.dotless=true;
    methodCall.arguments=EmptyArguments.INSTANCE;
    return methodCall;
  }
  return this;
}
Program: 84219
Project: 84219
Buggy source:
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  IClass iclass=this.type.getTheClass();
  if (iclass == null) {
    return;
  }
  if (iclass.hasModifier(Modifiers.OBJECT_CLASS)) {
    return;
  }
  markers.add(Markers.semantic(this.position,"String_Node_Str",this.type.toString()));
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context){
  this.type.check(markers,context);
  if (!this.type.isResolved()) {
    return;
  }
  final IClass iclass=this.type.getTheClass();
  if (iclass != null && iclass.hasModifier(Modifiers.OBJECT_CLASS)) {
    return;
  }
  markers.add(Markers.semantic(this.position,"String_Node_Str",this.type.toString()));
}
Program: 84220
Project: 84220
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.TYPE);
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.TYPE);
  if (!this.type.isResolved()) {
    markers.add(Markers.semantic(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString()));
  }
}
Program: 84221
Project: 84221
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,context);
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,context);
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
 else {
    this.value=this.type.getDefaultValue();
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
  }
}
Program: 84222
Project: 84222
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,context);
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  super.resolveTypes(markers,context);
  if (this.value != null) {
    this.value.resolveTypes(markers,context);
  }
 else {
    this.value=this.type.getDefaultValue();
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
  }
}
Program: 84223
Project: 84223
Buggy source:
@Override public IValue resolveCall(MarkerList markers,IContext context){
  IClass iclass=context.getThisClass();
  if (this.isSuper) {
    iclass=iclass.getSuperType().getTheClass();
  }
  IConstructor match=IContext.resolveConstructor(iclass,this.arguments);
  if (match != null) {
    this.constructor=match;
    this.checkArguments(markers,context);
    return this;
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue resolveCall(MarkerList markers,IContext context){
  IClass iclass=context.getThisClass();
  if (iclass == null) {
    return null;
  }
  if (this.isSuper) {
    iclass=iclass.getSuperType().getTheClass();
    if (iclass == null) {
      return null;
    }
  }
  final IConstructor match=IContext.resolveConstructor(iclass,this.arguments);
  if (match != null) {
    this.constructor=match;
    this.checkArguments(markers,context);
    return this;
  }
  return null;
}
Program: 84224
Project: 84224
Buggy source:
@Override public int getSuperTypeDistance(IType superType){
  IClass iclass=superType.getTheClass();
  if (this == iclass) {
    return 1;
  }
  int max=this.superType != null ? superType.getSubClassDistance(this.superType) : 0;
  if (!iclass.isInterface()) {
    return max;
  }
  for (int i=0; i < this.interfaceCount; i++) {
    int m=superType.getSubClassDistance(this.interfaces[i]);
    if (m > max) {
      max=m;
    }
  }
  return max == 0 ? 0 : 1 + max;
}

Fixed version (ground truth):
@Override public int getSuperTypeDistance(IType superType){
  IClass iclass=superType.getTheClass();
  if (iclass == null) {
    return 0;
  }
  if (this == iclass) {
    return 1;
  }
  int max=this.superType != null ? superType.getSubClassDistance(this.superType) : 0;
  if (!iclass.isInterface()) {
    return max;
  }
  for (int i=0; i < this.interfaceCount; i++) {
    int m=superType.getSubClassDistance(this.interfaces[i]);
    if (m > max) {
      max=m;
    }
  }
  return max == 0 ? 0 : 1 + max;
}
Program: 84225
Project: 84225
Buggy source:
@Override public boolean checkImplements(MarkerList markers,IClass checkedClass,IMethod candidate,ITypeContext typeContext){
  if (candidate.getTheClass() == this) {
    return !candidate.hasModifier(Modifiers.ABSTRACT);
  }
  if (this.body != null && this.body.checkImplements(markers,checkedClass,candidate,typeContext)) {
    return true;
  }
  if (this.superType != null) {
    if (this.superType.getTheClass().checkImplements(markers,checkedClass,candidate,this.superType.getConcreteType(typeContext))) {
      return true;
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    final IType interfaceType=this.interfaces[i];
    if (interfaceType.getTheClass().checkImplements(markers,checkedClass,candidate,interfaceType.getConcreteType(typeContext))) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean checkImplements(MarkerList markers,IClass checkedClass,IMethod candidate,ITypeContext typeContext){
  if (candidate.getTheClass() == this) {
    return !candidate.hasModifier(Modifiers.ABSTRACT);
  }
  if (this.body != null && this.body.checkImplements(markers,checkedClass,candidate,typeContext)) {
    return true;
  }
  if (this.superType != null) {
    final IClass superClass=this.superType.getTheClass();
    if (superClass != null && superClass.checkImplements(markers,checkedClass,candidate,this.superType.getConcreteType(typeContext))) {
      return true;
    }
  }
  for (int i=0; i < this.interfaceCount; i++) {
    final IType interfaceType=this.interfaces[i];
    final IClass interfaceClass=interfaceType.getTheClass();
    if (interfaceClass != null && interfaceClass.checkImplements(markers,checkedClass,candidate,interfaceType.getConcreteType(typeContext))) {
      return true;
    }
  }
  return false;
}
Program: 84226
Project: 84226
Buggy source:
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue instance,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,position,context,instance,arguments,typeContext);
}

Fixed version (ground truth):
@Override public IValue checkArguments(MarkerList markers,ICodePosition position,IContext context,IValue receiver,IArguments arguments,ITypeContext typeContext){
  if (!this.annotationsResolved) {
    this.resolveAnnotations();
  }
  if (!this.parametersResolved) {
    this.resolveParameters();
  }
  return super.checkArguments(markers,position,context,receiver,arguments,typeContext);
}
Program: 84227
Project: 84227
Buggy source:
@Override public boolean isSuperTypeOf(IType type){
  return this.typeParameter == type.getTypeVariable();
}

Fixed version (ground truth):
@Override public boolean isSuperTypeOf(IType type){
  return this.isSameType(type);
}
Program: 84228
Project: 84228
Buggy source:
@Override public boolean classEquals(IType type){
  return this.typeParameter == type.getTypeVariable();
}

Fixed version (ground truth):
@Override public boolean classEquals(IType type){
  return this.isSameType(type);
}
Program: 84229
Project: 84229
Buggy source:
@Override public boolean isSameType(IType type){
  return this.typeParameter == type.getTypeVariable();
}

Fixed version (ground truth):
@Override public boolean isSameType(IType type){
  return this.typeParameter == type.getReturnType().getTypeVariable();
}
Program: 84231
Project: 84231
Buggy source:
public void setAction(IValue action){
  this.action=action;
}

Fixed version (ground truth):
@Override public void setAction(IValue action){
  this.action=action;
}
Program: 84233
Project: 84233
Buggy source:
public IValue getAction(){
  return this.action;
}

Fixed version (ground truth):
@Override public IValue getAction(){
  return this.action;
}
Program: 84234
Project: 84234
Buggy source:
@Override default IType resolveType(MarkerList markers,IContext context){
  return null;
}

Fixed version (ground truth):
@Override default IType resolveType(ITypeParameter typeParameter){
  final IClass theClass=this.getTheClass();
  return theClass == null ? null : theClass.resolveType(typeParameter,this);
}
Program: 84235
Project: 84235
Buggy source:
/** 
 * @return the descriptor that contains the captured instance and capturedvariables (if present) as the argument types and the instantiated method type as the return type.
 */
private String getInvokeDescriptor(){
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  this.captureHelper.appendThisCaptureType(buffer);
  this.captureHelper.appendCaptureTypes(buffer);
  buffer.append(')');
  this.type.appendExtendedName(buffer);
  return buffer.toString();
}

Fixed version (ground truth):
/** 
 * @return the descriptor that contains the captured instance and captured variables (if present) as the argumenttypes and the instantiated method type as the return type.
 */
private String getInvokeDescriptor(){
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  this.captureHelper.appendThisCaptureType(buffer);
  this.captureHelper.appendCaptureTypes(buffer);
  buffer.append(')');
  this.type.appendExtendedName(buffer);
  return buffer.toString();
}
Program: 84236
Project: 84236
Buggy source:
/** 
 * @return the descriptor of the (synthetic) lambda callback method,including captured variables, parameter types and the return type.
 */
private String getLambdaDescriptor(){
  if (this.lambdaDesc != null) {
    return this.lambdaDesc;
  }
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  this.captureHelper.appendCaptureTypes(buffer);
  for (int i=this.directInvokeOpcode != 0 && this.directInvokeOpcode != Opcodes.INVOKESTATIC ? 1 : 0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  if (this.directInvokeOpcode == ClassFormat.H_NEWINVOKESPECIAL) {
    buffer.append('V');
  }
 else {
    this.returnType.appendExtendedName(buffer);
  }
  return this.lambdaDesc=buffer.toString();
}

Fixed version (ground truth):
/** 
 * @return the descriptor of the (synthetic) lambda callback method, including captured variables, parameter typesand the return type.
 */
private String getLambdaDescriptor(){
  if (this.lambdaDesc != null) {
    return this.lambdaDesc;
  }
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  this.captureHelper.appendCaptureTypes(buffer);
  for (int i=this.directInvokeOpcode != 0 && this.directInvokeOpcode != Opcodes.INVOKESTATIC ? 1 : 0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  if (this.directInvokeOpcode == ClassFormat.H_NEWINVOKESPECIAL) {
    buffer.append('V');
  }
 else {
    this.returnType.appendExtendedName(buffer);
  }
  return this.lambdaDesc=buffer.toString();
}
Program: 84237
Project: 84237
Buggy source:
/** 
 * @return the specialized method type of the SAM method, as opposed to{@link IMethod#getDescriptor()}.
 */
private String getSpecialDescriptor(){
  StringBuilder buffer=new StringBuilder();
  buffer.append('(');
  for (int i=0; i < this.parameterCount; i++) {
    this.parameters[i].getType().appendExtendedName(buffer);
  }
  buffer.append(')');
  this.returnType.appendExtendedName(buffer);
  return buffer.toString();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Fixed version (ground truth):
default void writeSet(MethodWriter writer,IValue receiver,IValue value,int lineNumber) throws BytecodeException {
  if (receiver != null) {
    receiver.writeExpression(writer,this.getTheClass().getType());
  }
  this.writeSet_PreValue(writer,lineNumber);
  value.writeExpression(writer,this.getType());
  this.writeSet_Wrap(writer,lineNumber);
  this.writeSet_Set(writer,lineNumber);
}