nus-yam/ex-repair huggingface dataset:
Program: 82886
Project: 82886
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  context=context.push(this);
  super.resolve(markers,context);
  for (int i=0; i < this.typeParameterCount; i++) {
    this.typeParameters[i].resolve(markers,context);
  }
  if (this.receiverType != null) {
    this.receiverType.resolve(markers,context);
  }
  this.parameters.resolve(markers,context);
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i].resolve(markers,context);
  }
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN && this.value.isResolved()) {
        markers.add(Markers.semantic(this.position,"String_Node_Str",this.name.unqualified));
      }
    }
    final TypeChecker.MarkerSupplier markerSupplier=TypeChecker.markerSupplier("String_Node_Str","String_Node_Str","String_Node_Str",this.name);
    this.value=TypeChecker.convertValue(this.value,this.type,this.type,markers,context,markerSupplier);
    if (inferType) {
      this.type=this.value.getType();
    }
  }
 else   if (this.type == Types.UNKNOWN) {
    markers.add(Markers.semantic(this.position,"String_Node_Str",this.name.unqualified));
    this.type=Types.ANY;
  }
  context.pop();
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  context=context.push(this);
  super.resolve(markers,context);
  for (int i=0; i < this.typeParameterCount; i++) {
    this.typeParameters[i].resolve(markers,context);
  }
  if (this.receiverType != null) {
    this.receiverType.resolve(markers,context);
  }
  this.parameters.resolve(markers,context);
  for (int i=0; i < this.exceptionCount; i++) {
    this.exceptions[i].resolve(markers,context);
  }
  if (this.value != null) {
    this.value=this.value.resolve(markers,context);
    boolean inferType=false;
    if (this.type == Types.UNKNOWN || this.type == null) {
      inferType=true;
      this.type=this.value.getType();
      if (this.type == Types.UNKNOWN && this.value.isResolved()) {
        markers.add(Markers.semantic(this.position,"String_Node_Str",this.name.unqualified));
      }
    }
    final TypeChecker.MarkerSupplier markerSupplier=TypeChecker.markerSupplier("String_Node_Str","String_Node_Str","String_Node_Str",this.name);
    this.value=TypeChecker.convertValue(this.value,this.type,this.type,markers,context,markerSupplier);
    if (inferType) {
      this.type=this.value.getType();
    }
  }
 else   if (this.type == Types.UNKNOWN) {
    markers.add(Markers.semantic(this.position,"String_Node_Str",this.name.unqualified));
    this.type=Types.ANY;
  }
  context.pop();
}
Program: 82887
Project: 82887
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  final IType returnType=context.getReturnType();
  if (this.value != null) {
    this.value.checkTypes(markers,context);
    if (returnType == null) {
      return;
    }
    final IType valueType=this.value.getType();
    if (!Types.isSuperType(returnType,valueType)) {
      final Marker marker=Markers.semanticError(this.position,"String_Node_Str");
      marker.addInfo(Markers.getSemantic("String_Node_Str",returnType));
      marker.addInfo(Markers.getSemantic("String_Node_Str",valueType));
      markers.add(marker);
    }
  }
 else   if (returnType != null && !Types.isSameClass(returnType,Types.VOID)) {
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
  }
}

Fixed version (ground truth):
@Override public void checkTypes(MarkerList markers,IContext context){
  final IType returnType=context.getReturnType();
  if (this.value != null) {
    this.value.checkTypes(markers,context);
    if (returnType == null || !this.value.isResolved()) {
      return;
    }
    final IType valueType=this.value.getType();
    if (!Types.isSuperType(returnType,valueType)) {
      final Marker marker=Markers.semanticError(this.position,"String_Node_Str");
      marker.addInfo(Markers.getSemantic("String_Node_Str",returnType));
      marker.addInfo(Markers.getSemantic("String_Node_Str",valueType));
      markers.add(marker);
    }
  }
 else   if (returnType != null && !Types.isSameClass(returnType,Types.VOID)) {
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
  }
}
Program: 82889
Project: 82889
Buggy source:
private boolean success(){
  return !this.hasSyntaxErrors || this.reportErrors;
}

Fixed version (ground truth):
private boolean success(MarkerList markers){
  if (!this.hasSyntaxErrors || this.reportErrors) {
    markers.addAll(this.markers);
    return true;
  }
  return false;
}
Program: 82890
Project: 82890
Buggy source:
public TryParserManager(Symbols symbols,TokenIterator tokens,MarkerList markers){
  super(symbols,tokens,markers);
}

Fixed version (ground truth):
@Deprecated public TryParserManager(Symbols symbols,TokenIterator tokens,MarkerList markers){
  super(symbols,tokens,markers);
}
Program: 82891
Project: 82891
Buggy source:
@Override public void report(Marker error){
  final boolean isError=error.isError();
  if (!this.hasSyntaxErrors && isError) {
    this.hasSyntaxErrors=true;
  }
  if (this.reportErrors || !isError) {
    super.report(error);
    this.reportedMarkers++;
  }
}

Fixed version (ground truth):
@Override public void report(Marker error){
  final boolean isError=error.isError();
  if (!this.hasSyntaxErrors && isError) {
    this.hasSyntaxErrors=true;
  }
  if (this.reportErrors || !isError) {
    super.report(error);
  }
}
Program: 82892
Project: 82892
Buggy source:
public boolean parse(Parser parser,int flags){
  this.parser=parser;
  this.hasSyntaxErrors=false;
  this.reportErrors=(flags & REPORT_ERRORS) != 0;
  IToken token=null;
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      if (!this.tokens.hasNext()) {
        break;
      }
      token=this.tokens.next();
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    if (this.parser == null) {
      if ((flags & EXIT_ON_ROOT) != 0) {
        return this.success();
      }
      this.reportUnparsed(token);
      continue;
    }
    if (!this.reportErrors && this.parser.reportErrors()) {
      if (this.hasSyntaxErrors) {
        return false;
      }
      this.reportErrors=true;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      this.reportError(token,ex);
      return this.success();
    }
    if (!this.success()) {
      return false;
    }
  }
  this.parseRemaining(token);
  return this.success();
}

Fixed version (ground truth):
public boolean parse(Parser parser,MarkerList markers,int flags){
  this.parser=parser;
  this.hasSyntaxErrors=false;
  this.markers=new MarkerList(markers.getI18n());
  this.reportErrors=(flags & REPORT_ERRORS) != 0;
  IToken token=null;
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      if (!this.tokens.hasNext()) {
        break;
      }
      token=this.tokens.next();
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    if (this.parser == null) {
      if ((flags & EXIT_ON_ROOT) != 0) {
        return this.success(markers);
      }
      this.reportUnparsed(token);
      continue;
    }
    if (!this.reportErrors && this.parser.reportErrors()) {
      if (this.hasSyntaxErrors) {
        return this.success(markers);
      }
      this.reportErrors=true;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    Exception ex) {
      this.reportError(token,ex);
      return this.success(markers);
    }
    if (this.hasSyntaxErrors && !this.reportErrors) {
      return this.success(markers);
    }
  }
  this.parseRemaining(token);
  return this.success(markers);
}
Program: 82893
Project: 82893
Buggy source:
public void resetTo(IToken token){
  this.tokens.jump(token);
  if (this.reportedMarkers >= 0) {
    this.markers.remove(this.reportedMarkers);
  }
  if (this.splitTokens == null) {
    return;
  }
  for (  IToken splitToken : this.splitTokens) {
    splitToken.prev().setNext(splitToken);
    splitToken.next().setPrev(splitToken);
  }
  this.splitTokens.clear();
}

Fixed version (ground truth):
public void resetTo(IToken token){
  this.tokens.jump(token);
  if (this.splitTokens == null) {
    return;
  }
  for (  IToken splitToken : this.splitTokens) {
    splitToken.prev().setNext(splitToken);
    splitToken.next().setPrev(splitToken);
  }
  this.splitTokens.clear();
}
Program: 82894
Project: 82894
Buggy source:
public void add(Marker marker){
  if (marker.isError()) {
    this.errors++;
  }
  if (marker.isWarning()) {
    this.warnings++;
  }
  int index=this.markerCount++;
  if (index >= this.markers.length) {
    Marker[] temp=new Marker[this.markerCount];
    System.arraycopy(this.markers,0,temp,0,this.markers.length);
    this.markers=temp;
  }
  this.markers[index]=marker;
}

Fixed version (ground truth):
public void add(Marker marker){
  if (marker.isError()) {
    this.errors++;
  }
  if (marker.isWarning()) {
    this.warnings++;
  }
  int index=this.markerCount++;
  if (index >= this.markers.length) {
    Marker[] temp=new Marker[this.markerCount << 1];
    System.arraycopy(this.markers,0,temp,0,index);
    this.markers=temp;
  }
  this.markers[index]=marker;
}
Program: 82895
Project: 82895
Buggy source:
private boolean tryParse(MarkerList markers,TokenIterator tokens,Parser parser,boolean reportErrors){
  this.parser.reset(markers,tokens);
  this.parser.resetTo(tokens.first());
  return this.parser.parse(parser,reportErrors);
}

Fixed version (ground truth):
private boolean tryParse(MarkerList markers,TokenIterator tokens,Parser parser,boolean reportErrors){
  this.parser.reset(markers,tokens);
  this.parser.resetTo(tokens.first());
  return this.parser.parse(parser,markers,reportErrors ? TryParserManager.REPORT_ERRORS : 0);
}
Program: 82896
Project: 82896
Buggy source:
public static IValue convertValue(IValue value,IType type,ITypeContext typeContext,MarkerList markers,IContext context,MarkerSupplier markerSupplier){
  final IType concreteType=type.getConcreteType(typeContext);
  final IValue newValue=convertValueDirect(value,concreteType,typeContext,markers,context);
  if (newValue != null) {
    if (typeContext != null && !typeContext.isReadonly()) {
      type.inferTypes(newValue.getType(),typeContext);
    }
    return newValue;
  }
  if (value.isResolved()) {
    markers.add(markerSupplier.createMarker(value.getPosition(),type,value.getType()));
  }
  return value;
}

Fixed version (ground truth):
public static IValue convertValue(IValue value,IType type,ITypeContext typeContext,MarkerList markers,IContext context,MarkerSupplier markerSupplier){
  final IType concreteType=type.getConcreteType(typeContext);
  final IValue newValue=convertValueDirect(value,concreteType,typeContext,markers,context);
  if (newValue != null) {
    if (typeContext != null && !typeContext.isReadonly()) {
      type.inferTypes(newValue.getType(),typeContext);
    }
    return newValue;
  }
  if (value.isResolved()) {
    markers.add(markerSupplier.createMarker(value.getPosition(),concreteType,value.getType()));
  }
  return value;
}
Program: 82897
Project: 82897
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
switch (this.operatorCount) {
case 0:
    return this.operands[0];
case 1:
  return createCall(this.operators[0],this.operands[0],this.operands[1]).resolve(markers,context);
}
final Stack<OperatorElement> operatorStack=new LinkedList<>();
final Stack<IValue> operandStack=new LinkedList<>();
operandStack.push(this.operands[0]);
for (int i=0; i < this.operatorCount; i++) {
final OperatorElement element1=this.operators[i];
OperatorElement element2;
while (!operatorStack.isEmpty()) {
  element2=operatorStack.peek();
  final int comparePrecedence=element1.operator.comparePrecedence(element2.operator);
  if (comparePrecedence < 0 || element1.operator.getAssociativity() != IOperator.RIGHT && comparePrecedence == 0) {
    operatorStack.pop();
    this.pushCall(operandStack,element2);
  }
 else {
    break;
  }
}
operatorStack.push(element1);
operandStack.push(this.operands[i + 1]);
}
while (!operatorStack.isEmpty()) {
this.pushCall(operandStack,operatorStack.pop());
}
return operandStack.pop().resolve(markers,context);
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
switch (this.operatorCount) {
case 0:
    return this.operands[0];
case 1:
  return createCall(this.operators[0],this.operands[0],this.operands[1]).resolve(markers,context);
}
final Stack<OperatorElement> operatorStack=new LinkedList<>();
final Stack<IValue> operandStack=new LinkedList<>();
operandStack.push(this.operands[0]);
for (int i=0; i < this.operatorCount; i++) {
final OperatorElement element1=this.operators[i];
OperatorElement element2;
while (!operatorStack.isEmpty()) {
  element2=operatorStack.peek();
  final int comparePrecedence=element1.operator.comparePrecedence(element2.operator);
  if (comparePrecedence < 0) {
    operatorStack.pop();
    this.pushCall(operandStack,element2);
    continue;
  }
  if (comparePrecedence == 0) {
switch (element1.operator.getAssociativity()) {
case IOperator.NONE:
      markers.add(Markers.semantic(element1.position,"String_Node_Str",element1.name));
case IOperator.LEFT:
    operatorStack.pop();
  this.pushCall(operandStack,element2);
continue;
}
}
break;
}
operatorStack.push(element1);
operandStack.push(this.operands[i + 1]);
}
while (!operatorStack.isEmpty()) {
this.pushCall(operandStack,operatorStack.pop());
}
return operandStack.pop().resolve(markers,context);
}
Program: 82898
Project: 82898
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  this.left=this.left.resolve(markers,context);
  this.right=this.right.resolve(markers,context);
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.left != null) {
    this.left=this.left.resolve(markers,context);
  }
 else {
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
    this.left=new WildcardValue(this.position);
  }
  if (this.right != null) {
    this.right=this.right.resolve(markers,context);
  }
 else {
    markers.add(Markers.semanticError(this.position,"String_Node_Str"));
    this.right=new WildcardValue(this.position);
  }
  return this;
}
Program: 82899
Project: 82899
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.left.resolveTypes(markers,context);
  this.right.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  if (this.left != null) {
    this.left.resolveTypes(markers,context);
  }
  if (this.right != null) {
    this.right.resolveTypes(markers,context);
  }
}
Program: 82900
Project: 82900
Buggy source:
@Override public void resolve(MarkerList markers,IContext context){
  this.arguments.resolve(markers,context);
  final IClass theClass=this.type.getTheClass();
  if (theClass == null) {
    return;
  }
  for (int i=0, count=theClass.parameterCount(); i < count; i++) {
    final IParameter parameter=theClass.getParameter(i);
    final IType parameterType=parameter.getType();
    final IValue value=this.arguments.getValue(i,parameter);
    if (value == null) {
      if (parameter.getValue() == null) {
        markers.add(Markers.semanticError(this.position,"String_Node_Str",this.type,parameter.getName()));
      }
      continue;
    }
    IValue typedValue=value.withType(parameterType,parameterType,markers,context);
    if (typedValue == null) {
      markers.add(TypeChecker.typeError(value,parameterType,parameterType,"String_Node_Str",parameter.getName()));
      continue;
    }
    typedValue=Util.constant(typedValue,markers,context);
    if (typedValue != value) {
      this.arguments.setValue(i,parameter,typedValue);
    }
  }
}

Fixed version (ground truth):
@Override public void resolve(MarkerList markers,IContext context){
  this.arguments.resolve(markers,context);
  final IClass theClass;
  if (this.type == null || (theClass=this.type.getTheClass()) == null) {
    return;
  }
  for (int i=0, count=theClass.parameterCount(); i < count; i++) {
    final IParameter parameter=theClass.getParameter(i);
    final IType parameterType=parameter.getType();
    final IValue value=this.arguments.getValue(i,parameter);
    if (value == null) {
      if (parameter.getValue() == null) {
        markers.add(Markers.semanticError(this.position,"String_Node_Str",this.type,parameter.getName()));
      }
      continue;
    }
    IValue typedValue=value.withType(parameterType,parameterType,markers,context);
    if (typedValue == null) {
      markers.add(TypeChecker.typeError(value,parameterType,parameterType,"String_Node_Str",parameter.getName()));
      continue;
    }
    typedValue=Util.constant(typedValue,markers,context);
    if (typedValue != value) {
      this.arguments.setValue(i,parameter,typedValue);
    }
  }
}
Program: 82901
Project: 82901
Buggy source:
@Override public void check(MarkerList markers,IContext context,ElementType target){
  if (this.type == null || !this.type.isResolved()) {
    return;
  }
  IClass theClass=this.type.getTheClass();
  if (!theClass.hasModifier(Modifiers.ANNOTATION)) {
    markers.add(Markers.semantic(this.position,"String_Node_Str",this.type.getName()));
    return;
  }
  if (target == null) {
    return;
  }
  IClassMetadata metadata=theClass.getMetadata();
  if (!metadata.isTarget(target)) {
    Marker error=Markers.semantic(this.position,"String_Node_Str",this.type.getName());
    error.addInfo(Markers.getSemantic("String_Node_Str",target));
    error.addInfo(Markers.getSemantic("String_Node_Str",metadata.getTargets()));
    markers.add(error);
  }
}

Fixed version (ground truth):
@Override public void check(MarkerList markers,IContext context,ElementType target){
  if (this.type == null || !this.type.isResolved()) {
    return;
  }
  final IClass theClass=this.type.getTheClass();
  if (!theClass.hasModifier(Modifiers.ANNOTATION)) {
    markers.add(Markers.semanticError(this.position,"String_Node_Str",this.type.getName()));
    return;
  }
  if (target == null) {
    return;
  }
  final IClassMetadata metadata=theClass.getMetadata();
  if (!metadata.isTarget(target)) {
    final Marker error=Markers.semanticError(this.position,"String_Node_Str",this.type.getName());
    error.addInfo(Markers.getSemantic("String_Node_Str",target));
    error.addInfo(Markers.getSemantic("String_Node_Str",metadata.getTargets()));
    markers.add(error);
  }
}
Program: 82902
Project: 82902
Buggy source:
@Override public void checkTypes(MarkerList markers,IContext context){
  this.type.checkType(markers,context,TypePosition.CLASS);
  this.arguments.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);
  }
  this.arguments.checkTypes(markers,context);
}
Program: 82903
Project: 82903
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.type=this.type.resolveType(markers,context);
  this.arguments.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(Markers.semanticError(this.position,"String_Node_Str"));
  }
  this.arguments.resolveTypes(markers,context);
}
Program: 82904
Project: 82904
Buggy source:
public static void checkMethodModifiers(MarkerList markers,IClassMember member,int modifiers,boolean hasValue){
  boolean isStatic=(modifiers & Modifiers.STATIC) != 0;
  boolean isAbstract=(modifiers & Modifiers.ABSTRACT) != 0;
  boolean isNative=(modifiers & Modifiers.NATIVE) != 0;
  if (isStatic && isAbstract) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
 else   if (isAbstract && isNative) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
 else {
    if (isStatic) {
      if (!hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
    if (isNative) {
      if (!hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
    if (isAbstract) {
      IClass theClass=member.getEnclosingClass();
      if (!theClass.isAbstract()) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member),theClass.getName()));
      }
      if (hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
  }
  if (!hasValue && !isAbstract && !isNative) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
}

Fixed version (ground truth):
public static void checkMethodModifiers(MarkerList markers,IClassMember member,int modifiers,boolean hasValue){
  boolean isStatic=(modifiers & Modifiers.STATIC) != 0;
  boolean isAbstract=(modifiers & Modifiers.ABSTRACT) != 0;
  boolean isNative=(modifiers & Modifiers.NATIVE) != 0;
  if (isStatic && isAbstract) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
 else   if (isAbstract && isNative) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
 else {
    if (isStatic) {
      if (!hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
    if (isNative) {
      if (!hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
    if (isAbstract) {
      IClass theClass=member.getEnclosingClass();
      if (!theClass.isAbstract()) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member),theClass.getName()));
      }
      if (hasValue) {
        markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
      }
    }
  }
  if (!hasValue && !isAbstract && !isNative&& !isStatic) {
    markers.add(Markers.semanticError(member.getPosition(),"String_Node_Str",Util.memberNamed(member)));
  }
}
Program: 82905
Project: 82905
Buggy source:
protected void parseRemaining(IToken token){
  if (token == null || this.hasStopped) {
    return;
  }
  while (this.parser != null) {
    token=token.next();
    Parser prevParser=this.parser;
    int mode=prevParser.getMode();
    prevParser.parse(this,token);
    if (this.parser == prevParser && this.parser.getMode() == mode) {
      break;
    }
  }
}

Fixed version (ground truth):
protected void parseRemaining(IToken token){
  if (token == null || this.hasStopped) {
    return;
  }
  while (this.parser != null) {
    token=token.next();
    Parser prevParser=this.parser;
    int mode=prevParser.getMode();
    this.tryParse(token,prevParser);
    if (this.parser == prevParser && this.parser.getMode() == mode) {
      break;
    }
  }
}
Program: 82906
Project: 82906
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: 82907
Project: 82907
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: 82909
Project: 82909
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: 82910
Project: 82910
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: 82911
Project: 82911
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: 82912
Project: 82912
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: 82913
Project: 82913
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: 82914
Project: 82914
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: 82915
Project: 82915
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: 82916
Project: 82916
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: 82917
Project: 82917
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: 82918
Project: 82918
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: 82919
Project: 82919
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: 82920
Project: 82920
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: 82921
Project: 82921
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: 82922
Project: 82922
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: 82923
Project: 82923
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: 82924
Project: 82924
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: 82925
Project: 82925
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: 82926
Project: 82926
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: 82927
Project: 82927
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: 82928
Project: 82928
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: 82929
Project: 82929
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: 82930
Project: 82930
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: 82932
Project: 82932
Buggy source:
public void setAction(IValue action){
  this.action=action;
}

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

Fixed version (ground truth):
@Override public IValue getAction(){
  return this.action;
}
Program: 82935
Project: 82935
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: 82936
Project: 82936
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: 82937
Project: 82937
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();
}