nus-yam/ex-repair huggingface dataset:
Program: 130392
Project: 130392
Buggy source:
private static void delegate(CompletionParameters parameters,final CompletionResultSet result,final InheritorsHolder inheritorsHolder){
  if (parameters.getCompletionType() == CompletionType.BASIC) {
    PsiElement position=parameters.getPosition();
    if (parameters.getInvocationCount() <= 1 && CSharpCompletionUtil.mayStartClassName(result) && CSharpCompletionUtil.isClassNamePossible(parameters)) {
      addTypesForUsing(parameters,result,inheritorsHolder);
      return;
    }
  }
  if (parameters.getCompletionType() == CompletionType.SMART && parameters.getInvocationCount() == 2) {
    result.runRemainingContributors(parameters.withInvocationCount(3),true);
  }
}

Fixed version (ground truth):
@RequiredReadAction private static void delegate(CompletionParameters parameters,final CompletionResultSet result,final InheritorsHolder inheritorsHolder){
  if (parameters.getCompletionType() == CompletionType.BASIC) {
    PsiElement position=parameters.getPosition();
    if (parameters.getInvocationCount() <= 1 && CSharpCompletionUtil.mayStartClassName(result) && CSharpCompletionUtil.isClassNamePossible(parameters)) {
      addTypesForUsing(parameters,result,inheritorsHolder);
      return;
    }
  }
  if (parameters.getCompletionType() == CompletionType.SMART && parameters.getInvocationCount() == 2) {
    result.runRemainingContributors(parameters.withInvocationCount(3),true);
  }
}
Program: 130393
Project: 130393
Buggy source:
@Override @RequiredReadAction public boolean process(DotNetTypeDeclaration typeDeclaration){
  if (inheritorsHolder.alreadyProcessed(typeDeclaration)) {
    return true;
  }
  consumeType(parameters,parent,result,insideUsing,typeDeclaration);
  return true;
}

Fixed version (ground truth):
@Override @RequiredReadAction public boolean process(DotNetTypeDeclaration typeDeclaration){
  if (inheritorsHolder.alreadyProcessed(typeDeclaration)) {
    return true;
  }
  targets.add(typeDeclaration);
  return true;
}
Program: 130394
Project: 130394
Buggy source:
@RequiredReadAction @Override public void fillCompletionVariants(CompletionParameters parameters,CompletionResultSet result){
  final InheritorsHolder holder=new InheritorsHolder(result);
  ResultTracker tracker=new ResultTracker(result){
    @Override public void consume(    CompletionResult plainResult){
      super.consume(plainResult);
      LookupElement element=plainResult.getLookupElement();
      Object o=element.getObject();
      if (o instanceof PsiElement && CSharpPsiUtilImpl.isTypeLikeElement((PsiElement)o)) {
        holder.registerTypeLike((DotNetQualifiedElement)o);
      }
    }
  }
;
  result.runRemainingContributors(parameters,tracker);
  final boolean empty=tracker.containsOnlyNamespaces;
  if (!empty && parameters.getInvocationCount() == 0) {
    result.restartCompletionWhenNothingMatches();
  }
  if (empty) {
    delegate(parameters,CSharpCompletionSorting.modifyResultSet(parameters,result),holder);
  }
 else {
    if (parameters.getCompletionType() == CompletionType.BASIC && parameters.getInvocationCount() <= 1 && CSharpCompletionUtil.mayStartClassName(result) && CSharpCompletionUtil.isClassNamePossible(parameters)) {
      addTypesForUsing(parameters,CSharpCompletionSorting.modifyResultSet(parameters,result.withPrefixMatcher(tracker.betterMatcher)),holder);
    }
  }
}

Fixed version (ground truth):
@RequiredReadAction @Override @RequiredDispatchThread public void fillCompletionVariants(CompletionParameters parameters,CompletionResultSet result){
  final InheritorsHolder holder=new InheritorsHolder(result);
  ResultTracker tracker=new ResultTracker(result){
    @Override public void consume(    CompletionResult plainResult){
      super.consume(plainResult);
      LookupElement element=plainResult.getLookupElement();
      Object o=element.getObject();
      if (o instanceof PsiElement && CSharpPsiUtilImpl.isTypeLikeElement((PsiElement)o)) {
        holder.registerTypeLike((DotNetQualifiedElement)o);
      }
    }
  }
;
  result.runRemainingContributors(parameters,tracker);
  final boolean empty=tracker.containsOnlyNamespaces;
  if (!empty && parameters.getInvocationCount() == 0) {
    result.restartCompletionWhenNothingMatches();
  }
  if (empty) {
    delegate(parameters,CSharpCompletionSorting.modifyResultSet(parameters,result),holder);
  }
 else {
    if (parameters.getCompletionType() == CompletionType.BASIC && parameters.getInvocationCount() <= 1 && CSharpCompletionUtil.mayStartClassName(result) && CSharpCompletionUtil.isClassNamePossible(parameters)) {
      addTypesForUsing(parameters,CSharpCompletionSorting.modifyResultSet(parameters,result.withPrefixMatcher(tracker.betterMatcher)),holder);
    }
  }
}
Program: 130396
Project: 130396
Buggy source:
@RequiredReadAction public static Owners toOwners(DotNetModifierListOwner owner){
  if (owner instanceof CSharpFieldDeclaration && ((CSharpFieldDeclaration)owner).isConstant()) {
    return Owners.Constant;
  }
  if (owner instanceof CSharpConstructorDeclaration) {
    if (((CSharpConstructorDeclaration)owner).isDeConstructor()) {
      return Owners.DeConstructor;
    }
    if (owner.hasModifier(DotNetModifier.STATIC)) {
      return Owners.StaticConstructor;
    }
    return Owners.Constructor;
  }
  if (owner instanceof CSharpMethodDeclaration || owner instanceof CSharpPropertyDeclaration || owner instanceof CSharpIndexMethodDeclaration) {
    PsiElement parent=owner.getParent();
    if (parent instanceof CSharpTypeDeclaration) {
      if (((CSharpTypeDeclaration)parent).isInterface()) {
        return Owners.InterfaceMember;
      }
    }
  }
  if (owner instanceof DotNetGenericParameter) {
    return Owners.GenericParameter;
  }
  if (owner instanceof DotNetTypeDeclaration) {
    PsiElement parent=owner.getParent();
    if (parent instanceof CSharpNamespaceDeclaration || parent instanceof CSharpFile) {
      return Owners.NamespaceType;
    }
 else     if (parent instanceof DotNetTypeDeclaration) {
      return Owners.NestedType;
    }
  }
  return Owners.Unknown;
}

Fixed version (ground truth):
@RequiredReadAction public static Owners toOwners(DotNetModifierListOwner owner){
  if (owner instanceof CSharpFieldDeclaration && ((CSharpFieldDeclaration)owner).isConstant()) {
    return Owners.Constant;
  }
  if (owner instanceof CSharpConstructorDeclaration) {
    if (((CSharpConstructorDeclaration)owner).isDeConstructor()) {
      return Owners.DeConstructor;
    }
    if (owner.hasModifier(DotNetModifier.STATIC)) {
      return Owners.StaticConstructor;
    }
    return Owners.Constructor;
  }
  if (owner instanceof CSharpMethodDeclaration || owner instanceof CSharpPropertyDeclaration || owner instanceof CSharpIndexMethodDeclaration) {
    PsiElement parent=owner.getParent();
    if (parent instanceof CSharpTypeDeclaration) {
      if (((CSharpTypeDeclaration)parent).isInterface()) {
        return Owners.InterfaceMember;
      }
    }
  }
  if (owner instanceof DotNetGenericParameter) {
    return Owners.GenericParameter;
  }
  if (owner instanceof DotNetTypeDeclaration) {
    boolean anEnum=((DotNetTypeDeclaration)owner).isEnum();
    PsiElement parent=owner.getParent();
    if (parent instanceof CSharpNamespaceDeclaration || parent instanceof CSharpFile) {
      return anEnum ? Owners.NamespaceEnum : Owners.NamespaceType;
    }
 else     if (parent instanceof DotNetTypeDeclaration) {
      return anEnum ? Owners.NestedEnum : Owners.NestedType;
    }
  }
  return Owners.Unknown;
}
Program: 130398
Project: 130398
Buggy source:
@Nullable String getReferenceName();

Fixed version (ground truth):
@Nullable @RequiredReadAction String getReferenceName();
Program: 130399
Project: 130399
Buggy source:
@Nullable String getReferenceNameWithAt();

Fixed version (ground truth):
@Nullable @RequiredReadAction String getReferenceNameWithAt();
Program: 130400
Project: 130400
Buggy source:
@Nullable PsiElement getQualifier();

Fixed version (ground truth):
@Nullable @RequiredReadAction PsiElement getQualifier();
Program: 130401
Project: 130401
Buggy source:
@NotNull DotNetTypeRef[] getTypeArgumentListRefs();

Fixed version (ground truth):
@NotNull @RequiredReadAction DotNetTypeRef[] getTypeArgumentListRefs();
Program: 130402
Project: 130402
Buggy source:
@Nullable PsiElement getMemberAccessElement();

Fixed version (ground truth):
@Nullable @RequiredReadAction PsiElement getMemberAccessElement();
Program: 130403
Project: 130403
Buggy source:
@NotNull AccessType getMemberAccessType();

Fixed version (ground truth):
@NotNull @RequiredReadAction AccessType getMemberAccessType();
Program: 130404
Project: 130404
Buggy source:
@NotNull ResolveToKind kind();

Fixed version (ground truth):
@NotNull @RequiredReadAction ResolveToKind kind();
Program: 130405
Project: 130405
Buggy source:
boolean isGlobalElement();

Fixed version (ground truth):
@RequiredReadAction boolean isGlobalElement();
Program: 130406
Project: 130406
Buggy source:
@Nullable PsiElement getReferenceElement();

Fixed version (ground truth):
@Nullable @RequiredReadAction PsiElement getReferenceElement();
Program: 130407
Project: 130407
Buggy source:
@Nullable DotNetTypeList getTypeArgumentList();

Fixed version (ground truth):
@Nullable @RequiredReadAction DotNetTypeList getTypeArgumentList();
Program: 130408
Project: 130408
Buggy source:
@NotNull ResolveResult[] multiResolve(final boolean incompleteCode,final boolean resolveFromParent);

Fixed version (ground truth):
@NotNull @RequiredReadAction ResolveResult[] multiResolve(final boolean incompleteCode,final boolean resolveFromParent);
Program: 130409
Project: 130409
Buggy source:
@NotNull DotNetTypeRef toTypeRefWithoutCaching(ResolveToKind kind,boolean resolveFromParent);

Fixed version (ground truth):
@NotNull @RequiredReadAction DotNetTypeRef toTypeRefWithoutCaching(ResolveToKind kind,boolean resolveFromParent);
Program: 130410
Project: 130410
Buggy source:
@NotNull ResolveResult[] tryResolveFromQualifier(@NotNull PsiElement element);

Fixed version (ground truth):
@NotNull @RequiredReadAction ResolveResult[] tryResolveFromQualifier(@NotNull PsiElement element);
Program: 130411
Project: 130411
Buggy source:
@NotNull ResolveResult[] multiResolveImpl(ResolveToKind kind,boolean resolveFromParent);

Fixed version (ground truth):
@NotNull @RequiredReadAction ResolveResult[] multiResolveImpl(ResolveToKind kind,boolean resolveFromParent);
Program: 130412
Project: 130412
Buggy source:
@Nullable @Override public String getReferenceName(){
  throw new UnsupportedOperationException();
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceName(){
  throw new UnsupportedOperationException();
}
Program: 130413
Project: 130413
Buggy source:
@Nullable @Override public String getReferenceNameWithAt(){
  throw new UnsupportedOperationException();
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceNameWithAt(){
  throw new UnsupportedOperationException();
}
Program: 130414
Project: 130414
Buggy source:
@Nullable @Override public String getReferenceName(){
  throw new UnsupportedOperationException();
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceName(){
  throw new UnsupportedOperationException();
}
Program: 130415
Project: 130415
Buggy source:
@Nullable @Override public String getReferenceNameWithAt(){
  throw new UnsupportedOperationException();
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceNameWithAt(){
  throw new UnsupportedOperationException();
}
Program: 130416
Project: 130416
Buggy source:
@Nullable @Override public PsiElement getQualifier(){
  return null;
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public PsiElement getQualifier(){
  return null;
}
Program: 130417
Project: 130417
Buggy source:
@NotNull @Override public ResolveResult[] tryResolveFromQualifier(@NotNull PsiElement element){
  return CSharpReferenceExpressionImplUtil.tryResolveFromQualifier(this,element);
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public ResolveResult[] tryResolveFromQualifier(@NotNull PsiElement element){
  return CSharpReferenceExpressionImplUtil.tryResolveFromQualifier(this,element);
}
Program: 130418
Project: 130418
Buggy source:
@Override @NotNull public DotNetTypeRef toTypeRefWithoutCaching(ResolveToKind kind,boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.toTypeRefWithoutCaching(this,kind,resolveFromParent);
}

Fixed version (ground truth):
@RequiredReadAction @Override @NotNull public DotNetTypeRef toTypeRefWithoutCaching(ResolveToKind kind,boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.toTypeRefWithoutCaching(this,kind,resolveFromParent);
}
Program: 130419
Project: 130419
Buggy source:
@Nullable @Override public PsiElement resolve(){
  return CSharpResolveUtil.findFirstValidElement(multiResolve(false));
}

Fixed version (ground truth):
@Nullable @Override @RequiredReadAction public PsiElement resolve(){
  return CSharpResolveUtil.findFirstValidElement(multiResolve(false));
}
Program: 130420
Project: 130420
Buggy source:
@Nullable @Override public String getReferenceName(){
  String referenceNameWithAt=getReferenceNameWithAt();
  return referenceNameWithAt == null ? null : CSharpPsiUtilImpl.getNameWithoutAt(referenceNameWithAt);
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceName(){
  String referenceNameWithAt=getReferenceNameWithAt();
  return referenceNameWithAt == null ? null : CSharpPsiUtilImpl.getNameWithoutAt(referenceNameWithAt);
}
Program: 130421
Project: 130421
Buggy source:
@Override @NotNull public ResolveResult[] multiResolveImpl(ResolveToKind kind,boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.multiResolveImpl(kind,CSharpReferenceExpressionImplUtil.findCallArgumentListOwner(kind,this),this,resolveFromParent);
}

Fixed version (ground truth):
@RequiredReadAction @Override @NotNull public ResolveResult[] multiResolveImpl(ResolveToKind kind,boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.multiResolveImpl(kind,CSharpReferenceExpressionImplUtil.findCallArgumentListOwner(kind,this),this,resolveFromParent);
}
Program: 130422
Project: 130422
Buggy source:
@Override @NotNull public ResolveResult[] multiResolve(final boolean incompleteCode,final boolean resolveFromParent){
  if (!isValid()) {
    return ResolveResult.EMPTY_ARRAY;
  }
  return CSharpResolveCache.getInstance(getProject()).resolveWithCaching(this,CSharpReferenceExpressionImplUtil.OurResolver.INSTANCE,true,incompleteCode,resolveFromParent);
}

Fixed version (ground truth):
@RequiredReadAction @Override @NotNull public ResolveResult[] multiResolve(final boolean incompleteCode,final boolean resolveFromParent){
  if (!isValid()) {
    return ResolveResult.EMPTY_ARRAY;
  }
  return CSharpResolveCache.getInstance(getProject()).resolveWithCaching(this,CSharpReferenceExpressionImplUtil.OurResolver.INSTANCE,true,incompleteCode,resolveFromParent);
}
Program: 130423
Project: 130423
Buggy source:
@Override @Nullable public PsiElement getReferenceElement(){
  return findChildByType(CSharpReferenceExpressionImplUtil.ourReferenceElements);
}

Fixed version (ground truth):
@RequiredReadAction @Override @Nullable public PsiElement getReferenceElement(){
  return findChildByType(CSharpReferenceExpressionImplUtil.ourReferenceElements);
}
Program: 130424
Project: 130424
Buggy source:
@Nullable @Override public DotNetTypeList getTypeArgumentList(){
  return findChildByClass(DotNetTypeList.class);
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public DotNetTypeList getTypeArgumentList(){
  return findChildByClass(DotNetTypeList.class);
}
Program: 130425
Project: 130425
Buggy source:
@Override public PsiElement handleElementRename(String s) throws IncorrectOperationException {
  PsiElement element=getReferenceElement();
  PsiElement newIdentifier=CSharpFileFactory.createReferenceToken(getProject(),s);
  element.replace(newIdentifier);
  return this;
}

Fixed version (ground truth):
@Override @RequiredWriteAction public PsiElement handleElementRename(String s) throws IncorrectOperationException {
}
Program: 130426
Project: 130426
Buggy source:
@Override public boolean isSoft(){
  return CSharpReferenceExpressionImplUtil.isSoft(this);
}

Fixed version (ground truth):
@Override @RequiredReadAction public boolean isSoft(){
  return CSharpReferenceExpressionImplUtil.isSoft(this);
}
Program: 130427
Project: 130427
Buggy source:
@Override public boolean isReferenceTo(PsiElement element){
  PsiElement resolve=resolve();
  if (element instanceof DotNetNamespaceAsElement && resolve instanceof DotNetNamespaceAsElement) {
    return Comparing.equal(((DotNetNamespaceAsElement)resolve).getPresentableQName(),((DotNetNamespaceAsElement)element).getPresentableQName());
  }
  return element.getManager().areElementsEquivalent(element,resolve);
}

Fixed version (ground truth):
@Override @RequiredReadAction public boolean isReferenceTo(PsiElement element){
  PsiElement resolve=resolve();
  if (element instanceof DotNetNamespaceAsElement && resolve instanceof DotNetNamespaceAsElement) {
    return Comparing.equal(((DotNetNamespaceAsElement)resolve).getPresentableQName(),((DotNetNamespaceAsElement)element).getPresentableQName());
  }
  return element.getManager().areElementsEquivalent(element,resolve);
}
Program: 130428
Project: 130428
Buggy source:
@Nullable @Override public PsiElement getMemberAccessElement(){
  return findChildByType(CSharpReferenceExpressionImplUtil.ourAccessTokens);
}

Fixed version (ground truth):
@Nullable @Override @RequiredReadAction public PsiElement getMemberAccessElement(){
  return findChildByType(CSharpReferenceExpressionImplUtil.ourAccessTokens);
}
Program: 130429
Project: 130429
Buggy source:
@Override public TextRange getRangeInElement(){
  return CSharpReferenceExpressionImplUtil.getRangeInElement(this);
}

Fixed version (ground truth):
@Override @RequiredReadAction public TextRange getRangeInElement(){
  return CSharpReferenceExpressionImplUtil.getRangeInElement(this);
}
Program: 130430
Project: 130430
Buggy source:
@NotNull @Override public AccessType getMemberAccessType(){
  PsiElement childByType=getMemberAccessElement();
  if (childByType == null) {
    return AccessType.NONE;
  }
  IElementType elementType=childByType.getNode().getElementType();
  if (elementType == CSharpTokens.ARROW) {
    return AccessType.ARROW;
  }
 else   if (elementType == CSharpTokens.COLONCOLON) {
    return AccessType.COLONCOLON;
  }
 else   if (elementType == CSharpTokens.NULLABE_CALL) {
    return AccessType.NULLABLE_CALL;
  }
  return AccessType.DOT;
}

Fixed version (ground truth):
@NotNull @Override @RequiredReadAction public AccessType getMemberAccessType(){
  PsiElement childByType=getMemberAccessElement();
  if (childByType == null) {
    return AccessType.NONE;
  }
  IElementType elementType=childByType.getNode().getElementType();
  if (elementType == CSharpTokens.ARROW) {
    return AccessType.ARROW;
  }
 else   if (elementType == CSharpTokens.COLONCOLON) {
    return AccessType.COLONCOLON;
  }
 else   if (elementType == CSharpTokens.NULLABE_CALL) {
    return AccessType.NULLABLE_CALL;
  }
  return AccessType.DOT;
}
Program: 130431
Project: 130431
Buggy source:
@Override @NotNull public ResolveToKind kind(){
  return CSharpReferenceExpressionImplUtil.kind(this);
}

Fixed version (ground truth):
@RequiredReadAction @Override @NotNull public ResolveToKind kind(){
  return CSharpReferenceExpressionImplUtil.kind(this);
}
Program: 130432
Project: 130432
Buggy source:
@NotNull @Override public String getCanonicalText(){
  return getText();
}

Fixed version (ground truth):
@NotNull @Override @RequiredReadAction public String getCanonicalText(){
  return getText();
}
Program: 130433
Project: 130433
Buggy source:
@NotNull @Override public DotNetTypeRef[] getTypeArgumentListRefs(){
  DotNetTypeList typeArgumentList=getTypeArgumentList();
  return typeArgumentList == null ? DotNetTypeRef.EMPTY_ARRAY : typeArgumentList.getTypeRefs();
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public DotNetTypeRef[] getTypeArgumentListRefs(){
  DotNetTypeList typeArgumentList=getTypeArgumentList();
  return typeArgumentList == null ? DotNetTypeRef.EMPTY_ARRAY : typeArgumentList.getTypeRefs();
}
Program: 130434
Project: 130434
Buggy source:
@Override public boolean isGlobalElement(){
  PsiElement referenceElement=getReferenceElement();
  return referenceElement != null && referenceElement.getNode().getElementType() == CSharpSoftTokens.GLOBAL_KEYWORD;
}

Fixed version (ground truth):
@RequiredReadAction @Override public boolean isGlobalElement(){
  PsiElement referenceElement=getReferenceElement();
  return referenceElement != null && referenceElement.getNode().getElementType() == CSharpSoftTokens.GLOBAL_KEYWORD;
}
Program: 130435
Project: 130435
Buggy source:
@Nullable @Override public String getReferenceNameWithAt(){
  PsiElement referenceElement=getReferenceElement();
  return referenceElement == null ? null : referenceElement.getText();
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public String getReferenceNameWithAt(){
  PsiElement referenceElement=getReferenceElement();
  return referenceElement == null ? null : referenceElement.getText();
}
Program: 130436
Project: 130436
Buggy source:
@NotNull @Override public DotNetTypeRef toTypeRef(boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.toTypeRef(this,resolveFromParent);
}

Fixed version (ground truth):
@NotNull @Override @RequiredReadAction public DotNetTypeRef toTypeRef(boolean resolveFromParent){
  return CSharpReferenceExpressionImplUtil.toTypeRef(this,resolveFromParent);
}
Program: 130437
Project: 130437
Buggy source:
@Nullable @RequiredReadAction public static Pair<DotNetTypeDeclaration,DotNetGenericExtractor> resolveBaseType(@NotNull DotNetTypeDeclaration typeDeclaration,@NotNull PsiElement scope){
  DotNetTypeRef[] anExtends=typeDeclaration.getExtendTypeRefs();
  if (anExtends.length != 0) {
    for (    DotNetTypeRef anExtend : anExtends) {
      DotNetTypeResolveResult resolveResult=anExtend.resolve(scope);
      PsiElement resolve=resolveResult.getElement();
      if (resolve instanceof DotNetTypeDeclaration && !((DotNetTypeDeclaration)resolve).isInterface()) {
        return Pair.create((DotNetTypeDeclaration)resolve,resolveResult.getGenericExtractor());
      }
    }
  }
  String defaultSuperType=getDefaultSuperType(typeDeclaration);
  if (defaultSuperType != null) {
    DotNetTypeDeclaration type=DotNetPsiSearcher.getInstance(typeDeclaration.getProject()).findType(defaultSuperType,scope.getResolveScope(),CSharpTransform.INSTANCE);
    if (type != null) {
      return Pair.create(type,DotNetGenericExtractor.EMPTY);
    }
  }
  return null;
}

Fixed version (ground truth):
@Nullable @RequiredReadAction public static Pair<DotNetTypeDeclaration,DotNetGenericExtractor> resolveBaseType(@NotNull DotNetTypeDeclaration typeDeclaration,@NotNull PsiElement scope){
  typeDeclaration=CSharpCompositeTypeDeclaration.selectCompositeOrSelfType(typeDeclaration);
  DotNetTypeRef[] anExtends=typeDeclaration.getExtendTypeRefs();
  if (anExtends.length != 0) {
    for (    DotNetTypeRef anExtend : anExtends) {
      DotNetTypeResolveResult resolveResult=anExtend.resolve(scope);
      PsiElement resolve=resolveResult.getElement();
      if (resolve instanceof DotNetTypeDeclaration && !((DotNetTypeDeclaration)resolve).isInterface()) {
        return Pair.create((DotNetTypeDeclaration)resolve,resolveResult.getGenericExtractor());
      }
    }
  }
  String defaultSuperType=getDefaultSuperType(typeDeclaration);
  if (defaultSuperType != null) {
    DotNetTypeDeclaration type=DotNetPsiSearcher.getInstance(typeDeclaration.getProject()).findType(defaultSuperType,scope.getResolveScope(),CSharpTransform.INSTANCE);
    if (type != null) {
      return Pair.create(type,DotNetGenericExtractor.EMPTY);
    }
  }
  return null;
}
Program: 130439
Project: 130439
Buggy source:
@Override public int getStubVersion(){
  return 75;
}

Fixed version (ground truth):
@Override public int getStubVersion(){
  return 76;
}
Program: 130441
Project: 130441
Buggy source:
@Override public int getStubVersion(){
  return 76;
}

Fixed version (ground truth):
@Override public int getStubVersion(){
  return 77;
}
Program: 130442
Project: 130442
Buggy source:
@RequiredReadAction @NotNull @Override public List<HighlightInfoFactory> check(@NotNull CSharpLanguageVersion languageVersion,@NotNull CSharpReferenceExpression expression){
  PsiElement referenceElement=expression.getReferenceElement();
  if (referenceElement == null || expression.isSoft() || CSharpDocUtil.isInsideDoc(expression)) {
    return Collections.emptyList();
  }
  if (expression.getParent() instanceof CSharpCallArgumentListOwner) {
    return Collections.emptyList();
  }
  return checkReference(expression,Arrays.asList(referenceElement));
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public List<HighlightInfoFactory> check(@NotNull CSharpLanguageVersion languageVersion,@NotNull CSharpReferenceExpression expression){
  PsiElement referenceElement=expression.getReferenceElement();
  if (referenceElement == null || expression.isSoft() || CSharpDocUtil.isInsideDoc(expression)) {
    return Collections.emptyList();
  }
  PsiElement parent=expression.getParent();
  if (parent instanceof CSharpMethodCallExpressionImpl || parent instanceof CSharpConstructorSuperCallImpl) {
    return Collections.emptyList();
  }
  return checkReference(expression,Arrays.asList(referenceElement));
}
Program: 130444
Project: 130444
Buggy source:
@Override @RequiredReadAction protected PsiFile createFile(String name,String templateName,PsiDirectory dir){
  DotNetSimpleModuleExtension<?> extension=ModuleUtilCore.getExtension(dir,DotNetModuleExtension.class);
  String namespace=null;
  if (extension != null) {
    namespace=extension.getNamespaceGeneratePolicy().calculateNamespace(dir);
  }
  FileTemplate template=FileTemplateManager.getInstance().getInternalTemplate(templateName);
  return createFileFromTemplate(name,namespace,template,dir);
}

Fixed version (ground truth):
@Override @RequiredReadAction protected PsiFile createFile(String name,String templateName,final PsiDirectory dir){
  DotNetSimpleModuleExtension<?> extension=ModuleUtilCore.getExtension(dir,DotNetSimpleModuleExtension.class);
  if (extension == null) {
    Module moduleByPsiDirectory=findModuleByPsiDirectory(dir.getProject(),dir);
    if (moduleByPsiDirectory != null) {
      extension=ModuleUtilCore.getExtension(moduleByPsiDirectory,DotNetSimpleModuleExtension.class);
    }
  }
  String namespace=null;
  if (extension != null) {
    namespace=extension.getNamespaceGeneratePolicy().calculateNamespace(dir);
  }
  FileTemplate template=FileTemplateManager.getInstance().getInternalTemplate(templateName);
  return createFileFromTemplate(name,namespace,template,dir);
}
Program: 130445
Project: 130445
Buggy source:
@Nullable @Override public IDocumentation resolveDocumentation(@NotNull List<VirtualFile> virtualFile,@NotNull PsiElement element){
  if (!(element instanceof DotNetQualifiedElement)) {
    return null;
  }
  PsiElement prevSibling=UsefulPsiTreeUtil.getPrevSiblingSkipWhiteSpaces(element,true);
  if (prevSibling instanceof CSharpDocRoot) {
    return new CSharpDocAsIDocumentation((CSharpDocRoot)prevSibling);
  }
  return null;
}

Fixed version (ground truth):
@Nullable @Override public IDocumentation resolveDocumentation(@NotNull List<VirtualFile> virtualFile,@NotNull PsiElement element){
  if (!(element instanceof DotNetQualifiedElement)) {
    return null;
  }
  CSharpDocRoot docRoot=PsiTreeUtil.getChildOfType(element,CSharpDocRoot.class);
  if (docRoot != null) {
    return new CSharpDocAsIDocumentation(docRoot);
  }
  return null;
}
Program: 130446
Project: 130446
Buggy source:
@Override @Nullable public DotNetModifierList getModifierList(){
  return findChildByClass(DotNetModifierList.class);
}

Fixed version (ground truth):
@RequiredReadAction @Override @Nullable public DotNetModifierList getModifierList(){
  return findChildByClass(DotNetModifierList.class);
}
Program: 130447
Project: 130447
Buggy source:
@Override public PsiElement setName(@NonNls @NotNull String s) throws IncorrectOperationException {
  CSharpRefactoringUtil.replaceNameIdentifier(this,s);
  return this;
}

Fixed version (ground truth):
@Override @RequiredReadAction public PsiElement setName(@NonNls @NotNull String s) throws IncorrectOperationException {
  CSharpRefactoringUtil.replaceNameIdentifier(this,s);
  return this;
}
Program: 130448
Project: 130448
Buggy source:
@Override public String getName(){
  return CSharpPsiUtilImpl.getNameWithoutAt(this);
}

Fixed version (ground truth):
@Override @RequiredReadAction public String getName(){
  return CSharpPsiUtilImpl.getNameWithoutAt(this);
}
Program: 130449
Project: 130449
Buggy source:
@Nullable @Override public PsiElement getNameIdentifier(){
  return findChildByType(CSharpTokens.IDENTIFIER);
}

Fixed version (ground truth):
@Nullable @Override public PsiElement getNameIdentifier(){
  return findNotNullChildByClass(CSharpIdentifier.class);
}
Program: 130450
Project: 130450
Buggy source:
@Nullable @Override public DotNetExpression getInitializer(){
  return findChildByClass(DotNetExpression.class);
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public DotNetExpression getInitializer(){
  return findChildByClass(DotNetExpression.class);
}
Program: 130451
Project: 130451
Buggy source:
@Override public boolean isConstant(){
  return false;
}

Fixed version (ground truth):
@RequiredReadAction @Override public boolean isConstant(){
  return false;
}
Program: 130452
Project: 130452
Buggy source:
@NotNull @Override public DotNetType getType(){
  return findChildByClass(DotNetType.class);
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public DotNetType getType(){
  return findChildByClass(DotNetType.class);
}
Program: 130453
Project: 130453
Buggy source:
@Override public boolean hasModifier(@NotNull DotNetModifier modifier){
  DotNetModifierList modifierList=getModifierList();
  return modifierList != null && modifierList.hasModifier(modifier);
}

Fixed version (ground truth):
@RequiredReadAction @Override public boolean hasModifier(@NotNull DotNetModifier modifier){
  DotNetModifierList modifierList=getModifierList();
  return modifierList != null && modifierList.hasModifier(modifier);
}
Program: 130454
Project: 130454
Buggy source:
@Override public int getTextOffset(){
  PsiElement nameIdentifier=getNameIdentifier();
  return nameIdentifier == null ? super.getTextOffset() : nameIdentifier.getTextOffset();
}

Fixed version (ground truth):
@RequiredReadAction @Override public int getTextOffset(){
  PsiElement nameIdentifier=getNameIdentifier();
  return nameIdentifier == null ? super.getTextOffset() : nameIdentifier.getTextOffset();
}
Program: 130455
Project: 130455
Buggy source:
@NotNull @Override public DotNetTypeRef toTypeRef(boolean resolveFromInitializer){
  DotNetType type=getType();
  DotNetTypeRef typeRef=type.toTypeRef();
  if (hasModifier(CSharpModifier.REF)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.ref,typeRef);
  }
 else   if (hasModifier(CSharpModifier.OUT)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.out,typeRef);
  }
  return typeRef;
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public DotNetTypeRef toTypeRef(boolean resolveFromInitializer){
  DotNetType type=getType();
  DotNetTypeRef typeRef=type.toTypeRef();
  if (hasModifier(CSharpModifier.REF)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.ref,typeRef);
  }
 else   if (hasModifier(CSharpModifier.OUT)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.out,typeRef);
  }
  return typeRef;
}
Program: 130456
Project: 130456
Buggy source:
@Nullable @Override public PsiElement getConstantKeywordElement(){
  return null;
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public PsiElement getConstantKeywordElement(){
  return null;
}
Program: 130457
Project: 130457
Buggy source:
private static void parseLambdaParameter(CSharpBuilderWrapper builder){
  val mark=builder.mark();
  if (MODIFIERS.contains(builder.getTokenType())) {
    parseModifierList(builder,NONE);
    if (parseType(builder) == null) {
      builder.error("String_Node_Str");
    }
 else {
      expect(builder,CSharpTokens.IDENTIFIER,"String_Node_Str");
    }
  }
 else {
    IElementType iElementType=builder.lookAhead(1);
    if (builder.getTokenType() == CSharpTokens.IDENTIFIER && (iElementType == COMMA || iElementType == RPAR || iElementType == DARROW)) {
      builder.advanceLexer();
    }
 else {
      if (parseType(builder) == null) {
        builder.error("String_Node_Str");
      }
 else {
        expect(builder,CSharpTokens.IDENTIFIER,"String_Node_Str");
      }
    }
  }
  mark.done(LAMBDA_PARAMETER);
}

Fixed version (ground truth):
private static void parseLambdaParameter(CSharpBuilderWrapper builder){
  val mark=builder.mark();
  if (MODIFIERS.contains(builder.getTokenType())) {
    parseModifierList(builder,NONE);
    if (parseType(builder) == null) {
      builder.error("String_Node_Str");
    }
 else {
      expectOrReportIdentifier(builder,0);
    }
  }
 else {
    IElementType iElementType=builder.lookAhead(1);
    if (builder.getTokenType() == CSharpTokens.IDENTIFIER && (iElementType == COMMA || iElementType == RPAR || iElementType == DARROW)) {
      expectOrReportIdentifier(builder,0);
    }
 else {
      if (parseType(builder) == null) {
        builder.error("String_Node_Str");
      }
 else {
        expectOrReportIdentifier(builder,0);
      }
    }
  }
  mark.done(LAMBDA_PARAMETER);
}
Program: 130458
Project: 130458
Buggy source:
@RequiredReadAction @Override @Nullable public PsiElement getNameIdentifier(){
  return findChildByType(CSharpTokens.IDENTIFIER);
}

Fixed version (ground truth):
@RequiredReadAction @Override @Nullable public PsiElement getNameIdentifier(){
  return getStubOrPsiChild(CSharpStubElements.IDENTIFIER);
}
Program: 130459
Project: 130459
Buggy source:
private static boolean parseEnumConstant(CSharpBuilderWrapper builder){
  if (builder.getTokenType() == RBRACE) {
    return true;
  }
  PsiBuilder.Marker mark=builder.mark();
  boolean nameExpected=false;
  if (builder.getTokenType() == LBRACKET) {
    PsiBuilder.Marker modMark=builder.mark();
    parseAttributeList(builder,STUB_SUPPORT);
    modMark.done(CSharpStubElements.MODIFIER_LIST);
    nameExpected=true;
  }
  if (builder.getTokenType() == CSharpTokens.IDENTIFIER) {
    if (!nameExpected) {
      emptyElement(builder,CSharpStubElements.MODIFIER_LIST);
    }
    doneIdentifier(builder,0);
    if (builder.getTokenType() == EQ) {
      builder.advanceLexer();
      if (ExpressionParsing.parse(builder) == null) {
        builder.error("String_Node_Str");
      }
    }
  }
 else {
    if (builder.getTokenType() == COMMA || builder.getTokenType() == RBRACE) {
      if (nameExpected) {
        PsiBuilder.Marker identifierMarker=builder.mark();
        builder.error("String_Node_Str");
        identifierMarker.done(CSharpStubElements.IDENTIFIER);
      }
      done(mark,ENUM_CONSTANT_DECLARATION);
      return false;
    }
  }
  done(mark,ENUM_CONSTANT_DECLARATION);
  return true;
}

Fixed version (ground truth):
private static boolean parseEnumConstant(CSharpBuilderWrapper builder){
  if (builder.getTokenType() == RBRACE) {
    return true;
  }
  PsiBuilder.Marker mark=builder.mark();
  boolean nameExpected=false;
  if (builder.getTokenType() == LBRACKET) {
    PsiBuilder.Marker modMark=builder.mark();
    parseAttributeList(builder,STUB_SUPPORT);
    modMark.done(CSharpStubElements.MODIFIER_LIST);
    nameExpected=true;
  }
  if (builder.getTokenType() == CSharpTokens.IDENTIFIER) {
    if (!nameExpected) {
      emptyElement(builder,CSharpStubElements.MODIFIER_LIST);
    }
    doneIdentifier(builder,STUB_SUPPORT);
    if (builder.getTokenType() == EQ) {
      builder.advanceLexer();
      if (ExpressionParsing.parse(builder) == null) {
        builder.error("String_Node_Str");
      }
    }
  }
 else {
    if (builder.getTokenType() == COMMA || builder.getTokenType() == RBRACE) {
      if (nameExpected) {
        PsiBuilder.Marker identifierMarker=builder.mark();
        builder.error("String_Node_Str");
        identifierMarker.done(CSharpStubElements.IDENTIFIER);
      }
      done(mark,ENUM_CONSTANT_DECLARATION);
      return false;
    }
  }
  done(mark,ENUM_CONSTANT_DECLARATION);
  return true;
}
Program: 130460
Project: 130460
Buggy source:
@Override public void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item){
  generateReturn(builder,item);
}

Fixed version (ground truth):
@RequiredReadAction @Override public void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item){
  generateReturn(builder,item);
}
Program: 130461
Project: 130461
Buggy source:
@Override public void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item){
  if (OverrideUtil.isRequireOverrideModifier((DotNetModifierListOwner)item)) {
    builder.append("String_Node_Str");
  }
}

Fixed version (ground truth):
@RequiredReadAction @Override public void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item){
  CSharpModifier requiredOverrideModifier=OverrideUtil.getRequiredOverrideModifier((DotNetModifierListOwner)item);
  if (requiredOverrideModifier != null) {
    builder.append(requiredOverrideModifier.getPresentableText()).append("String_Node_Str");
  }
}
Program: 130462
Project: 130462
Buggy source:
public abstract void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item);

Fixed version (ground truth):
@RequiredReadAction public abstract void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item);
Program: 130463
Project: 130463
Buggy source:
public abstract void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item);

Fixed version (ground truth):
@RequiredReadAction public abstract void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item);
Program: 130464
Project: 130464
Buggy source:
@Override public void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item){
  generateReturn(builder,item);
}

Fixed version (ground truth):
@RequiredReadAction @Override public void processReturn(@NotNull StringBuilder builder,@NotNull PsiElement item){
  generateReturn(builder,item);
}
Program: 130465
Project: 130465
Buggy source:
@Override public void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item){
}

Fixed version (ground truth):
@RequiredReadAction @Override public void processItem(@NotNull StringBuilder builder,@NotNull PsiElement item){
  CSharpModifier requiredOverrideModifier=OverrideUtil.getRequiredOverrideModifier((DotNetModifierListOwner)item);
  if (requiredOverrideModifier != null) {
    builder.append(requiredOverrideModifier.getPresentableText()).append("String_Node_Str");
  }
}
Program: 130466
Project: 130466
Buggy source:
@Override public String getText(){
  StringBuilder builder=new StringBuilder();
  CSharpAccessModifier modifier=CSharpAccessModifier.findModifier(myDeclaration);
  boolean canGenerateCodeBlock=canGenerateCodeBlock();
  if (modifier != CSharpAccessModifier.NONE && canGenerateCodeBlock) {
    builder.append(modifier.getPresentableText()).append("String_Node_Str");
  }
  builder.append(getPresentationText());
  if (canGenerateCodeBlock) {
    builder.append("String_Node_Str");
    processReturn(builder);
    builder.append("String_Node_Str");
  }
 else {
    builder.append("String_Node_Str");
  }
  return builder.toString();
}

Fixed version (ground truth):
@Override public String getText(){
  StringBuilder builder=new StringBuilder();
  CSharpAccessModifier modifier=CSharpAccessModifier.findModifier(myDeclaration);
  boolean canGenerateCodeBlock=canGenerateCodeBlock();
  if (modifier != CSharpAccessModifier.NONE && canGenerateCodeBlock) {
    builder.append(modifier.getPresentableText()).append("String_Node_Str");
  }
  process(builder);
  builder.append(getPresentationText());
  if (canGenerateCodeBlock) {
    builder.append("String_Node_Str");
    processReturn(builder);
    builder.append("String_Node_Str");
  }
 else {
    builder.append("String_Node_Str");
  }
  return builder.toString();
}
Program: 130468
Project: 130468
Buggy source:
@Override public PsiElement handleElementRename(String s) throws IncorrectOperationException {
  PsiElement element=getReferenceElement();
  PsiElement newIdentifier=CSharpFileFactory.createIdentifier(getProject(),s);
  element.replace(newIdentifier);
  return this;
}

Fixed version (ground truth):
@Override public PsiElement handleElementRename(String s) throws IncorrectOperationException {
  PsiElement element=getReferenceElement();
  PsiElement newIdentifier=CSharpFileFactory.createReferenceToken(getProject(),s);
  element.replace(newIdentifier);
  return this;
}
Program: 130469
Project: 130469
Buggy source:
@Override @Nullable public DotNetModifierList getModifierList(){
  return getStubOrPsiChild(CSharpStubElements.MODIFIER_LIST);
}

Fixed version (ground truth):
@RequiredReadAction @Override @Nullable public DotNetModifierList getModifierList(){
  return getStubOrPsiChild(CSharpStubElements.MODIFIER_LIST);
}
Program: 130470
Project: 130470
Buggy source:
@Override public String getName(){
  CSharpVariableDeclStub<?> stub=getStub();
  if (stub != null) {
    return stub.getName();
  }
  return CSharpPsiUtilImpl.getNameWithoutAt(this);
}

Fixed version (ground truth):
@Override @RequiredReadAction public String getName(){
  CSharpVariableDeclStub<?> stub=getStub();
  if (stub != null) {
    return stub.getName();
  }
  return CSharpPsiUtilImpl.getNameWithoutAt(this);
}
Program: 130471
Project: 130471
Buggy source:
@Nullable @Override public PsiElement getNameIdentifier(){
  return findChildByType(CSharpTokens.IDENTIFIER);
}

Fixed version (ground truth):
@Nullable @Override @RequiredReadAction public PsiElement getNameIdentifier(){
  return getStubOrPsiChild(CSharpStubElements.IDENTIFIER);
}
Program: 130472
Project: 130472
Buggy source:
@Nullable @Override public DotNetExpression getInitializer(){
  return findChildByClass(DotNetExpression.class);
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public DotNetExpression getInitializer(){
  return findChildByClass(DotNetExpression.class);
}
Program: 130473
Project: 130473
Buggy source:
@Override public boolean isConstant(){
  return false;
}

Fixed version (ground truth):
@RequiredReadAction @Override public boolean isConstant(){
  return false;
}
Program: 130474
Project: 130474
Buggy source:
@NotNull @Override public DotNetType getType(){
  return getRequiredStubOrPsiChildByIndex(CSharpStubElements.TYPE_SET,0);
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public DotNetType getType(){
  return getRequiredStubOrPsiChildByIndex(CSharpStubElements.TYPE_SET,0);
}
Program: 130475
Project: 130475
Buggy source:
@Override public boolean hasModifier(@NotNull DotNetModifier modifier){
  DotNetModifierList modifierList=getModifierList();
  return modifierList != null && modifierList.hasModifier(modifier);
}

Fixed version (ground truth):
@RequiredReadAction @Override public boolean hasModifier(@NotNull DotNetModifier modifier){
  DotNetModifierList modifierList=getModifierList();
  return modifierList != null && modifierList.hasModifier(modifier);
}
Program: 130476
Project: 130476
Buggy source:
@Override public int getTextOffset(){
  PsiElement nameIdentifier=getNameIdentifier();
  return nameIdentifier == null ? super.getTextOffset() : nameIdentifier.getTextOffset();
}

Fixed version (ground truth):
@RequiredReadAction @Override public int getTextOffset(){
  PsiElement nameIdentifier=getNameIdentifier();
  return nameIdentifier == null ? super.getTextOffset() : nameIdentifier.getTextOffset();
}
Program: 130477
Project: 130477
Buggy source:
@NotNull @Override public DotNetTypeRef toTypeRef(boolean resolveFromInitializer){
  DotNetType type=getType();
  DotNetTypeRef typeRef=type.toTypeRef();
  if (hasModifier(CSharpModifier.REF)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.ref,typeRef);
  }
 else   if (hasModifier(CSharpModifier.OUT)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.out,typeRef);
  }
  return typeRef;
}

Fixed version (ground truth):
@RequiredReadAction @NotNull @Override public DotNetTypeRef toTypeRef(boolean resolveFromInitializer){
  DotNetType type=getType();
  DotNetTypeRef typeRef=type.toTypeRef();
  if (hasModifier(CSharpModifier.REF)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.ref,typeRef);
  }
 else   if (hasModifier(CSharpModifier.OUT)) {
    return new CSharpRefTypeRef(CSharpRefTypeRef.Type.out,typeRef);
  }
  return typeRef;
}
Program: 130478
Project: 130478
Buggy source:
@Nullable @Override public PsiElement getConstantKeywordElement(){
  return null;
}

Fixed version (ground truth):
@RequiredReadAction @Nullable @Override public PsiElement getConstantKeywordElement(){
  return null;
}
Program: 130479
Project: 130479
Buggy source:
public CSharpXXXAccessorStub(StubElement parent,String name,int otherModifiers){
  super(parent,CSharpStubElements.XXX_ACCESSOR,name,null,otherModifiers);
}

Fixed version (ground truth):
public CSharpXXXAccessorStub(StubElement parent,int otherModifiers){
  super(parent,CSharpStubElements.XXX_ACCESSOR,(StringRef)null,null,otherModifiers);
}
Program: 130480
Project: 130480
Buggy source:
@Override public int getStubVersion(){
  return 66;
}

Fixed version (ground truth):
@Override public int getStubVersion(){
  return 67;
}
Program: 130481
Project: 130481
Buggy source:
@Override public void serialize(@NotNull CSharpXXXAccessorStub stub,@NotNull StubOutputStream stubOutputStream) throws IOException {
  stubOutputStream.writeName(stub.getName());
  stubOutputStream.writeInt(stub.getOtherModifierMask());
}

Fixed version (ground truth):
@Override public void serialize(@NotNull CSharpXXXAccessorStub stub,@NotNull StubOutputStream stubOutputStream) throws IOException {
  stubOutputStream.writeInt(stub.getOtherModifierMask());
}
Program: 130482
Project: 130482
Buggy source:
@Override public CSharpXXXAccessorStub createStub(@NotNull DotNetXXXAccessor accessor,StubElement stubElement){
  String name=accessor.getName();
  int otherModifiers=CSharpXXXAccessorStub.getOtherModifiers(accessor);
  return new CSharpXXXAccessorStub(stubElement,name,otherModifiers);
}

Fixed version (ground truth):
@RequiredReadAction @Override public CSharpXXXAccessorStub createStub(@NotNull DotNetXXXAccessor accessor,StubElement stubElement){
  int otherModifiers=CSharpXXXAccessorStub.getOtherModifiers(accessor);
  return new CSharpXXXAccessorStub(stubElement,otherModifiers);
}
Program: 130483
Project: 130483
Buggy source:
@NotNull @Override public CSharpXXXAccessorStub deserialize(@NotNull StubInputStream inputStream,StubElement stubElement) throws IOException {
  StringRef name=inputStream.readName();
  int otherModifiers=inputStream.readInt();
  return new CSharpXXXAccessorStub(stubElement,name,otherModifiers);
}

Fixed version (ground truth):
@NotNull @Override public CSharpXXXAccessorStub deserialize(@NotNull StubInputStream inputStream,StubElement stubElement) throws IOException {
  int otherModifiers=inputStream.readInt();
  return new CSharpXXXAccessorStub(stubElement,otherModifiers);
}