nus-yam/ex-repair huggingface dataset:
Program: 9701
Project: 9701
Buggy source:
private void replaceEffectivelyStaticRef(MessageSend call){
  NameReference receiver=(NameReference)call.receiver;
  receiver.binding=thisJoinPointStaticPartDecLocal;
  receiver.codegenBinding=thisJoinPointStaticPartDecLocal;
  call.binding.declaringClass=(ReferenceBinding)thisJoinPointStaticPartDec.type;
}

Fixed version (ground truth):
private void replaceEffectivelyStaticRef(MessageSend call){
  NameReference receiver=(NameReference)call.receiver;
  receiver.binding=thisJoinPointStaticPartDecLocal;
  receiver.codegenBinding=thisJoinPointStaticPartDecLocal;
  call.binding=call.codegenBinding=getEquivalentStaticBinding(call.binding);
}
Program: 9702
Project: 9702
Buggy source:
public boolean incrementalBuild(AjBuildConfig buildConfig,IMessageHandler messageHandler) throws CoreException, IOException {
  if (javaBuilder == null || javaBuilder.currentProject == null) {
    return batchBuild(buildConfig,messageHandler);
  }
  final CountingMessageHandler counter=new CountingMessageHandler(messageHandler);
  try {
    currentHandler=counter;
    IncrementalBuilder builder=getIncrementalBuilder(messageHandler);
    IContainer[] sourceFolders=new IContainer[buildConfig.getSourceRoots().size()];
    int count=0;
    for (Iterator i=buildConfig.getSourceRoots().iterator(); i.hasNext(); count++) {
      sourceFolders[count]=new FilesystemFolder(((File)i.next()).getAbsolutePath());
    }
    builder.setSourceFolders(sourceFolders);
    getJavaBuilder().binaryResources=new SimpleLookupTable();
    SimpleLookupTable deltas=getDeltas(buildConfig);
    boolean succeeded=builder.build(deltas);
    if (counter.hasErrors()) {
      return false;
    }
    if (succeeded) {
      return weaveAndGenerateClassFiles(builder.getNewState());
    }
 else {
      return batchBuild(buildConfig,messageHandler);
    }
  }
  finally {
    currentHandler=null;
  }
}

Fixed version (ground truth):
public boolean incrementalBuild(AjBuildConfig buildConfig,IMessageHandler messageHandler) throws CoreException, IOException {
  if (javaBuilder == null || javaBuilder.currentProject == null || javaBuilder.lastState == null) {
    return batchBuild(buildConfig,messageHandler);
  }
  final CountingMessageHandler counter=new CountingMessageHandler(messageHandler);
  try {
    currentHandler=counter;
    IncrementalBuilder builder=getIncrementalBuilder(messageHandler);
    IContainer[] sourceFolders=new IContainer[buildConfig.getSourceRoots().size()];
    int count=0;
    for (Iterator i=buildConfig.getSourceRoots().iterator(); i.hasNext(); count++) {
      sourceFolders[count]=new FilesystemFolder(((File)i.next()).getAbsolutePath());
    }
    builder.setSourceFolders(sourceFolders);
    getJavaBuilder().binaryResources=new SimpleLookupTable();
    SimpleLookupTable deltas=getDeltas(buildConfig);
    boolean succeeded=builder.build(deltas);
    if (counter.hasErrors()) {
      return false;
    }
    if (succeeded) {
      return weaveAndGenerateClassFiles(builder.getNewState());
    }
 else {
      return batchBuild(buildConfig,messageHandler);
    }
  }
  finally {
    currentHandler=null;
  }
}
Program: 9703
Project: 9703
Buggy source:
void run(){
  assignLabels();
  print();
}

Fixed version (ground truth):
void run(){
  killNops();
  assignLabels();
  print();
}
Program: 9704
Project: 9704
Buggy source:
public LazyMethodGen(Method m,LazyClassGen enclosingClass){
  this.enclosingClass=enclosingClass;
  if (!m.isAbstract() && m.getCode() == null) {
    throw new RuntimeException("String_Node_Str" + m + "String_Node_Str"+ enclosingClass);
  }
  MethodGen gen=new MethodGen(m,enclosingClass.getName(),enclosingClass.getConstantPoolGen());
  this.memberView=new BcelMethod(enclosingClass.getType(),m);
  this.accessFlags=gen.getAccessFlags();
  this.returnType=gen.getReturnType();
  this.name=gen.getName();
  this.argumentTypes=gen.getArgumentTypes();
  this.declaredExceptions=gen.getExceptions();
  this.attributes=gen.getAttributes();
  this.maxLocals=gen.getMaxLocals();
  if (gen.isAbstract() || gen.isNative()) {
    body=null;
  }
 else {
    body=gen.getInstructionList();
    unpackHandlers(gen);
    unpackLineNumbers(gen);
    unpackLocals(gen);
  }
  assertGoodBody();
}

Fixed version (ground truth):
public LazyMethodGen(Method m,LazyClassGen enclosingClass){
  this.enclosingClass=enclosingClass;
  if (!(m.isAbstract() || m.isNative()) && m.getCode() == null) {
    throw new RuntimeException("String_Node_Str" + m + "String_Node_Str"+ enclosingClass);
  }
  MethodGen gen=new MethodGen(m,enclosingClass.getName(),enclosingClass.getConstantPoolGen());
  this.memberView=new BcelMethod(enclosingClass.getType(),m);
  this.accessFlags=gen.getAccessFlags();
  this.returnType=gen.getReturnType();
  this.name=gen.getName();
  this.argumentTypes=gen.getArgumentTypes();
  this.declaredExceptions=gen.getExceptions();
  this.attributes=gen.getAttributes();
  this.maxLocals=gen.getMaxLocals();
  if (gen.isAbstract() || gen.isNative()) {
    body=null;
  }
 else {
    body=gen.getInstructionList();
    unpackHandlers(gen);
    unpackLineNumbers(gen);
    unpackLocals(gen);
  }
  assertGoodBody();
}
Program: 9705
Project: 9705
Buggy source:
/** 
 * @param packageName	if null default package is searched
 * @param className 	can't be null
 */
public ProgramElementNode findNodeForClass(String packageName,String className){
  StructureNode packageNode=null;
  if (packageName == null) {
    packageNode=root;
  }
 else {
    for (Iterator it=root.getChildren().iterator(); it.hasNext(); ) {
      StructureNode node=(StructureNode)it.next();
      if (packageName.equals(node.getName())) {
        packageNode=node;
      }
    }
    if (packageNode == null)     return null;
  }
  for (Iterator it=packageNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode fileNode=(ProgramElementNode)it.next();
    for (Iterator j=fileNode.getChildren().iterator(); j.hasNext(); ) {
      ProgramElementNode classNode=(ProgramElementNode)j.next();
      if (classNode instanceof ProgramElementNode && className.equals(classNode.getName())) {
        return (ProgramElementNode)classNode;
      }
    }
  }
  return null;
}

Fixed version (ground truth):
/** 
 * @param packageName	if null default package is searched
 * @param className 	can't be null
 */
public ProgramElementNode findNodeForClass(String packageName,String className){
  StructureNode packageNode=null;
  if (packageName == null) {
    packageNode=root;
  }
 else {
    for (Iterator it=root.getChildren().iterator(); it.hasNext(); ) {
      StructureNode node=(StructureNode)it.next();
      if (packageName.equals(node.getName())) {
        packageNode=node;
      }
    }
    if (packageNode == null)     return null;
  }
  for (Iterator it=packageNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode fileNode=(ProgramElementNode)it.next();
    ProgramElementNode ret=findClassInNodes(fileNode.getChildren(),className);
    if (ret != null)     return ret;
  }
  return null;
}
Program: 9706
Project: 9706
Buggy source:
private static ProgramElementNode findOrCreateBodyNode(ProgramElementNode enclosingNode,Member shadowSig,Shadow shadow){
  for (Iterator it=enclosingNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode node=(ProgramElementNode)it.next();
    if (shadowSig.getName().equals(node.getBytecodeName()) && shadowSig.getSignature().equals(node.getBytecodeSignature())) {
      return node;
    }
  }
  ISourceLocation sl=shadow.getSourceLocation();
  ProgramElementNode peNode=new ProgramElementNode(shadow.toString(),ProgramElementNode.Kind.CODE,new SourceLocation(enclosingNode.getSourceLocation().getSourceFile(),sl.getLine()),0,"String_Node_Str",new ArrayList());
  System.err.println(peNode.getSourceLocation());
  peNode.setBytecodeName(shadowSig.getName());
  peNode.setBytecodeSignature(shadowSig.getSignature());
  enclosingNode.addChild(peNode);
  return peNode;
}

Fixed version (ground truth):
private static ProgramElementNode findOrCreateBodyNode(ProgramElementNode enclosingNode,Member shadowSig,Shadow shadow){
  for (Iterator it=enclosingNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode node=(ProgramElementNode)it.next();
    if (shadowSig.getName().equals(node.getBytecodeName()) && shadowSig.getSignature().equals(node.getBytecodeSignature())) {
      return node;
    }
  }
  ISourceLocation sl=shadow.getSourceLocation();
  ProgramElementNode peNode=new ProgramElementNode(shadow.toString(),ProgramElementNode.Kind.CODE,new SourceLocation(enclosingNode.getSourceLocation().getSourceFile(),sl.getLine()),0,"String_Node_Str",new ArrayList());
  peNode.setBytecodeName(shadowSig.getName());
  peNode.setBytecodeSignature(shadowSig.getSignature());
  enclosingNode.addChild(peNode);
  return peNode;
}
Program: 9707
Project: 9707
Buggy source:
private static ProgramElementNode getNode(StructureModel model,Shadow shadow){
  Member enclosingMember=shadow.getEnclosingCodeSignature();
  ProgramElementNode enclosingNode=lookupMember(model,enclosingMember);
  Member shadowSig=shadow.getSignature();
  if (!shadowSig.equals(enclosingMember)) {
    ProgramElementNode bodyNode=findOrCreateBodyNode(enclosingNode,shadowSig,shadow);
    return bodyNode;
  }
 else {
    return enclosingNode;
  }
}

Fixed version (ground truth):
private static ProgramElementNode getNode(StructureModel model,Shadow shadow){
  Member enclosingMember=shadow.getEnclosingCodeSignature();
  ProgramElementNode enclosingNode=lookupMember(model,enclosingMember);
  if (enclosingNode == null) {
    Lint.Kind err=shadow.getIWorld().getLint().shadowNotInStructure;
    if (err.isEnabled()) {
      err.signal(shadow.toString(),shadow.getSourceLocation());
    }
    return null;
  }
  Member shadowSig=shadow.getSignature();
  if (!shadowSig.equals(enclosingMember)) {
    ProgramElementNode bodyNode=findOrCreateBodyNode(enclosingNode,shadowSig,shadow);
    return bodyNode;
  }
 else {
    return enclosingNode;
  }
}
Program: 9708
Project: 9708
Buggy source:
private static ProgramElementNode findMemberInClass(ProgramElementNode classNode,Member member){
  if (classNode == null)   return null;
  for (Iterator it=classNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode node=(ProgramElementNode)it.next();
    if (member.getName().equals(node.getBytecodeName()) && member.getSignature().equals(node.getBytecodeSignature())) {
      return node;
    }
  }
  return null;
}

Fixed version (ground truth):
private static ProgramElementNode findMemberInClass(ProgramElementNode classNode,Member member){
  if (classNode == null)   return null;
  for (Iterator it=classNode.getChildren().iterator(); it.hasNext(); ) {
    ProgramElementNode node=(ProgramElementNode)it.next();
    if (member.getName().equals(node.getBytecodeName()) && member.getSignature().equals(node.getBytecodeSignature())) {
      return node;
    }
  }
  return classNode;
}
Program: 9709
Project: 9709
Buggy source:
/** 
 * Actually implement the (non-empty) mungers associated with this shadow 
 */
private void implementMungers(){
  World world=getIWorld();
  for (Iterator iter=mungers.iterator(); iter.hasNext(); ) {
    ShadowMunger munger=(ShadowMunger)iter.next();
    munger.implementOn(this);
    if (world.getModel() != null) {
      System.err.println("String_Node_Str" + munger + "String_Node_Str"+ this);
      AsmAdaptor.noteMunger(world.getModel(),this,munger);
    }
  }
}

Fixed version (ground truth):
/** 
 * Actually implement the (non-empty) mungers associated with this shadow 
 */
private void implementMungers(){
  World world=getIWorld();
  for (Iterator iter=mungers.iterator(); iter.hasNext(); ) {
    ShadowMunger munger=(ShadowMunger)iter.next();
    munger.implementOn(this);
    if (world.getModel() != null) {
      AsmAdaptor.noteMunger(world.getModel(),this,munger);
    }
  }
}
Program: 9710
Project: 9710
Buggy source:
/** 
 * This field goes on the class the field is declared onto
 */
public static ResolvedMember interFieldClassField(ResolvedMember field,TypeX aspectType){
  return new ResolvedMember(Member.FIELD,field.getDeclaringType(),makePublic(field.getModifiers()),field.getReturnType(),NameMangler.interFieldClassField(field.getModifiers(),aspectType,field.getDeclaringType(),field.getName()),TypeX.NONE);
}

Fixed version (ground truth):
/** 
 * This field goes on the class the field is declared onto
 */
public static ResolvedMember interFieldClassField(ResolvedMember field,TypeX aspectType){
  return new ResolvedMember(Member.FIELD,field.getDeclaringType(),makePublicNonFinal(field.getModifiers()),field.getReturnType(),NameMangler.interFieldClassField(field.getModifiers(),aspectType,field.getDeclaringType(),field.getName()),TypeX.NONE);
}
Program: 9711
Project: 9711
Buggy source:
/** 
 * This method goes on the target type of the inter-type method. (and possibly the topmost-implemeters, if the target type is an interface) 
 */
public static ResolvedMember interMethod(ResolvedMember meth,TypeX aspectType,boolean onInterface){
  if (Modifier.isPublic(meth.getModifiers()) && !onInterface)   return meth;
  int modifiers=makePublic(meth.getModifiers());
  if (onInterface)   modifiers|=Modifier.ABSTRACT;
  return new ResolvedMember(Member.METHOD,meth.getDeclaringType(),modifiers,meth.getReturnType(),NameMangler.interMethod(meth.getModifiers(),aspectType,meth.getDeclaringType(),meth.getName()),meth.getParameterTypes());
}

Fixed version (ground truth):
/** 
 * This method goes on the target type of the inter-type method. (and possibly the topmost-implemeters, if the target type is an interface) 
 */
public static ResolvedMember interMethod(ResolvedMember meth,TypeX aspectType,boolean onInterface){
  if (Modifier.isPublic(meth.getModifiers()) && !onInterface)   return meth;
  int modifiers=makePublicNonFinal(meth.getModifiers());
  if (onInterface)   modifiers|=Modifier.ABSTRACT;
  return new ResolvedMember(Member.METHOD,meth.getDeclaringType(),modifiers,meth.getReturnType(),NameMangler.interMethod(meth.getModifiers(),aspectType,meth.getDeclaringType(),meth.getName()),meth.getParameterTypes());
}
Program: 9712
Project: 9712
Buggy source:
/** 
 * This field goes on top-most implementers of the interface the field is declared onto
 */
public static ResolvedMember interFieldInterfaceField(ResolvedMember field,TypeX onClass,TypeX aspectType){
  return new ResolvedMember(Member.FIELD,onClass,makePublic(field.getModifiers()),field.getReturnType(),NameMangler.interFieldInterfaceField(aspectType,field.getDeclaringType(),field.getName()),TypeX.NONE);
}

Fixed version (ground truth):
/** 
 * This field goes on top-most implementers of the interface the field is declared onto
 */
public static ResolvedMember interFieldInterfaceField(ResolvedMember field,TypeX onClass,TypeX aspectType){
  return new ResolvedMember(Member.FIELD,onClass,makePublicNonFinal(field.getModifiers()),field.getReturnType(),NameMangler.interFieldInterfaceField(aspectType,field.getDeclaringType(),field.getName()),TypeX.NONE);
}
Program: 9713
Project: 9713
Buggy source:
public void resolve(IScope scope){
  patterns=patterns.resolveBindings(scope,Bindings.NONE,false,false);
  for (int i=0; i < patterns.size(); i++) {
    TypePattern pi=patterns.get(i);
    if (pi.isStar())     continue;
    ResolvedTypeX exactType=pi.getExactType().resolve(scope.getWorld());
    if (exactType == ResolvedTypeX.MISSING)     continue;
    for (int j=0; j < patterns.size(); j++) {
      if (j == i)       continue;
      TypePattern pj=patterns.get(j);
      if (pj.isStar())       continue;
      if (pj.matchesStatically(exactType)) {
        scope.getWorld().showMessage(IMessage.ERROR,"String_Node_Str" + exactType.getName() + "String_Node_Str",pi.getSourceLocation(),pj.getSourceLocation());
      }
    }
  }
}

Fixed version (ground truth):
public void resolve(IScope scope){
  patterns=patterns.resolveBindings(scope,Bindings.NONE,false,false);
  boolean seenStar=false;
  for (int i=0; i < patterns.size(); i++) {
    TypePattern pi=patterns.get(i);
    if (pi.isStar()) {
      if (seenStar) {
        scope.getWorld().showMessage(IMessage.ERROR,"String_Node_Str",pi.getSourceLocation(),null);
      }
      seenStar=true;
      continue;
    }
    ResolvedTypeX exactType=pi.getExactType().resolve(scope.getWorld());
    if (exactType == ResolvedTypeX.MISSING)     continue;
    for (int j=0; j < patterns.size(); j++) {
      if (j == i)       continue;
      TypePattern pj=patterns.get(j);
      if (pj.isStar())       continue;
      if (pj.matchesStatically(exactType)) {
        scope.getWorld().showMessage(IMessage.ERROR,"String_Node_Str" + exactType.getName() + "String_Node_Str",pi.getSourceLocation(),pj.getSourceLocation());
      }
    }
  }
}
Program: 9715
Project: 9715
Buggy source:
public void weaveSoftener(BcelAdvice munger,TypeX catchType){
  InstructionFactory fact=getFactory();
  InstructionList handler=new InstructionList();
  BcelVar exceptionVar=genTempVar(catchType);
  exceptionVar.appendStore(handler,fact);
  handler.append(fact.createNew(NameMangler.SOFT_EXCEPTION_TYPE));
  handler.append(fact.createDup(1));
  handler.append(exceptionVar.createLoad(fact));
  handler.append(fact.createInvoke(NameMangler.SOFT_EXCEPTION_TYPE,"String_Node_Str",Type.VOID,new Type[]{Type.THROWABLE},Constants.INVOKESPECIAL));
  handler.append(fact.ATHROW);
  InstructionHandle handlerStart=handler.getStart();
  if (isFallsThrough()) {
    InstructionHandle jumpTarget=range.getEnd();
    handler.insert(fact.createBranchInstruction(Constants.GOTO,jumpTarget));
  }
  InstructionHandle protectedEnd=handler.getStart();
  range.insert(handler,Range.InsideAfter);
  enclosingMethod.addExceptionHandler(range.getStart().getNext(),protectedEnd.getPrev(),handlerStart,(ObjectType)BcelWorld.makeBcelType(catchType),getKind().hasHighPriorityExceptions());
}

Fixed version (ground truth):
public void weaveSoftener(BcelAdvice munger,TypeX catchType){
  if (getRange().getStart().getNext() == getRange().getEnd())   return;
  InstructionFactory fact=getFactory();
  InstructionList handler=new InstructionList();
  BcelVar exceptionVar=genTempVar(catchType);
  exceptionVar.appendStore(handler,fact);
  handler.append(fact.createNew(NameMangler.SOFT_EXCEPTION_TYPE));
  handler.append(fact.createDup(1));
  handler.append(exceptionVar.createLoad(fact));
  handler.append(fact.createInvoke(NameMangler.SOFT_EXCEPTION_TYPE,"String_Node_Str",Type.VOID,new Type[]{Type.THROWABLE},Constants.INVOKESPECIAL));
  handler.append(fact.ATHROW);
  InstructionHandle handlerStart=handler.getStart();
  if (isFallsThrough()) {
    InstructionHandle jumpTarget=range.getEnd();
    handler.insert(fact.createBranchInstruction(Constants.GOTO,jumpTarget));
  }
  InstructionHandle protectedEnd=handler.getStart();
  range.insert(handler,Range.InsideAfter);
  enclosingMethod.addExceptionHandler(range.getStart().getNext(),protectedEnd.getPrev(),handlerStart,(ObjectType)BcelWorld.makeBcelType(catchType),getKind().hasHighPriorityExceptions());
}
Program: 9716
Project: 9716
Buggy source:
public LazyMethodGen getAjcClinit(){
  for (Iterator i=methodGens.iterator(); i.hasNext(); ) {
    LazyMethodGen gen=(LazyMethodGen)i.next();
    if (gen.getName().equals(NameMangler.AJC_CLINIT_NAME))     return gen;
  }
  throw new RuntimeException("String_Node_Str");
}

Fixed version (ground truth):
public LazyMethodGen getAjcClinit(){
  for (Iterator i=methodGens.iterator(); i.hasNext(); ) {
    LazyMethodGen gen=(LazyMethodGen)i.next();
    if (gen.getName().equals(NameMangler.AJC_CLINIT_NAME))     return gen;
  }
  LazyMethodGen ajcClinit=new LazyMethodGen(Modifier.STATIC,Type.VOID,NameMangler.AJC_CLINIT_NAME,new Type[0],CollectionUtil.NO_STRINGS,this);
  ajcClinit.getBody().insert(getFactory().RETURN);
  methodGens.add(ajcClinit);
  getStaticInitializer().getBody().insert(Utility.createInvoke(getFactory(),ajcClinit));
  return ajcClinit;
}
Program: 9717
Project: 9717
Buggy source:
protected boolean copyFile(File fromFile,File toFile,boolean filter){
  Copy copy=makeCopyTask(filter);
  copy.setFile(fromFile);
  copy.setTofile(toFile);
  executeTask(copy);
  return true;
}

Fixed version (ground truth):
/** 
 * Copy file, optionally filtering. (Filters set in project.)
 * @param fromFile the readable File source to copy
 * @param toFile the writable File destination file
 * @param boolean filter if true, enable filtering
 * @see org.aspectj.internal.tools.build.Builder#copyFile(File,File,boolean)
 */
protected boolean copyFile(File fromFile,File toFile,boolean filter){
  Copy copy=makeCopyTask(filter);
  copy.setFile(fromFile);
  copy.setTofile(toFile);
  executeTask(copy);
  return true;
}
Program: 9718
Project: 9718
Buggy source:
protected boolean buildInstaller(BuildSpec buildSpec,String targDirPath){
  if (buildSpec.verbose) {
    handler.log("String_Node_Str" + buildSpec);
  }
  AJInstaller installer=new AJInstaller();
  installer.setProject(project);
  installer.setBasedir(targDirPath);
  File installSrcDir=new File(buildSpec.productDir,"String_Node_Str");
  Util.iaxIfNotCanReadDir(installSrcDir,"String_Node_Str");
  installer.setHtmlSrc(installSrcDir.getPath());
  String resourcePath=getProductInstallResourcesSrc(buildSpec);
  File resourceSrcDir=new File(resourcePath);
  Util.iaxIfNotCanReadDir(resourceSrcDir,"String_Node_Str");
  installer.setResourcesSrc(resourcePath);
  String name=getProductInstallerFileName(buildSpec);
  File outFile=new File(buildSpec.jarDir,name);
  installer.setZipfile(outFile.getPath());
  installer.setMainclass(getProductInstallerMainClass(buildSpec));
  installer.setInstallerclassjar(getBuildJar(buildSpec));
  return executeTask(installer);
}

Fixed version (ground truth):
protected boolean buildInstaller(BuildSpec buildSpec,String targDirPath){
  if (buildSpec.verbose) {
    handler.log("String_Node_Str" + buildSpec);
  }
  AJInstaller installer=new AJInstaller();
  setupTask(installer,"String_Node_Str");
  installer.setBasedir(targDirPath);
  File installSrcDir=new File(buildSpec.productDir,"String_Node_Str");
  Util.iaxIfNotCanReadDir(installSrcDir,"String_Node_Str");
  installer.setHtmlSrc(installSrcDir.getPath());
  String resourcePath=getProductInstallResourcesSrc(buildSpec);
  File resourceSrcDir=new File(resourcePath);
  Util.iaxIfNotCanReadDir(resourceSrcDir,"String_Node_Str");
  installer.setResourcesSrc(resourcePath);
  String name=getProductInstallerFileName(buildSpec);
  File outFile=new File(buildSpec.jarDir,name);
  installer.setZipfile(outFile.getPath());
  installer.setMainclass(getProductInstallerMainClass(buildSpec));
  installer.setInstallerclassjar(getBuildJar(buildSpec));
  return executeTask(installer);
}
Program: 9719
Project: 9719
Buggy source:
/** 
 * filter if FILTER_ON, use filters 
 */
protected Copy makeCopyTask(boolean filter){
  Copy copy=new Copy();
  copy.setProject(project);
  if (FILTER_ON == filter) {
    copy.setFiltering(true);
  }
  return copy;
}

Fixed version (ground truth):
/** 
 * @param filter if FILTER_ON, use filters 
 */
protected Copy makeCopyTask(boolean filter){
  Copy copy=new Copy();
  setupTask(copy,"String_Node_Str");
  if (FILTER_ON == filter) {
    copy.setFiltering(true);
  }
  return copy;
}
Program: 9721
Project: 9721
Buggy source:
/** 
 * Generate Module.assembledJar with merge of itself and all antecedants
 */
protected boolean assembleAll(Module module,Messager handler){
  if (!buildingEnabled) {
    return false;
  }
  Util.iaxIfNull(module,"String_Node_Str");
  Util.iaxIfNull(handler,"String_Node_Str");
  if (module.outOfDate(false)) {
    throw new IllegalStateException("String_Node_Str" + module);
  }
  Zip zip=new Zip();
  zip.setProject(project);
  zip.setDestFile(module.getAssembledJar());
  ZipFileSet zipfileset=null;
  ArrayList known=module.findKnownJarAntecedants();
  for (Iterator iter=known.iterator(); iter.hasNext(); ) {
    File jarFile=(File)iter.next();
    zipfileset=new ZipFileSet();
    zipfileset.setProject(project);
    zipfileset.setSrc(jarFile);
    zipfileset.setIncludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zip.addZipfileset(zipfileset);
  }
  zipfileset=new ZipFileSet();
  zipfileset.setProject(project);
  zipfileset.setSrc(module.getModuleJar());
  zip.addZipfileset(zipfileset);
  try {
    handler.log("String_Node_Str" + module + "String_Node_Str"+ module.getAssembledJar());
    if (verbose) {
      handler.log("String_Node_Str" + known);
    }
    return executeTask(zip);
  }
 catch (  BuildException e) {
    handler.logException("String_Node_Str" + module,e);
    return false;
  }
 finally {
    module.clearOutOfDate();
  }
}

Fixed version (ground truth):
/** 
 * Generate Module.assembledJar with merge of itself and all antecedants
 */
protected boolean assembleAll(Module module,Messager handler){
  if (!buildingEnabled) {
    return false;
  }
  Util.iaxIfNull(module,"String_Node_Str");
  Util.iaxIfNull(handler,"String_Node_Str");
  if (module.outOfDate(false)) {
    throw new IllegalStateException("String_Node_Str" + module);
  }
  Zip zip=new Zip();
  setupTask(zip,"String_Node_Str");
  zip.setDestFile(module.getAssembledJar());
  ZipFileSet zipfileset=null;
  ArrayList known=module.findKnownJarAntecedants();
  for (Iterator iter=known.iterator(); iter.hasNext(); ) {
    File jarFile=(File)iter.next();
    zipfileset=new ZipFileSet();
    zipfileset.setProject(project);
    zipfileset.setSrc(jarFile);
    zipfileset.setIncludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zipfileset.setExcludes("String_Node_Str");
    zip.addZipfileset(zipfileset);
  }
  zipfileset=new ZipFileSet();
  zipfileset.setProject(project);
  zipfileset.setSrc(module.getModuleJar());
  zip.addZipfileset(zipfileset);
  try {
    handler.log("String_Node_Str" + module + "String_Node_Str"+ module.getAssembledJar());
    if (verbose) {
      handler.log("String_Node_Str" + known);
    }
    return executeTask(zip);
  }
 catch (  BuildException e) {
    handler.logException("String_Node_Str" + module,e);
    return false;
  }
 finally {
    module.clearOutOfDate();
  }
}
Program: 9722
Project: 9722
Buggy source:
protected boolean compile(Module module,File classesDir,List errors){
  Javac javac=new Javac();
  javac.setProject(project);
  javac.setTaskName("String_Node_Str");
  Path path=new Path(project);
  for (Iterator iter=module.getSrcDirs().iterator(); iter.hasNext(); ) {
    File file=(File)iter.next();
    path.createPathElement().setLocation(file);
  }
  javac.setSrcdir(path);
  path=null;
  Path classpath=new Path(project);
  boolean hasLibraries=false;
  for (Iterator iter=module.getRequired().iterator(); iter.hasNext(); ) {
    Module required=(Module)iter.next();
    classpath.createPathElement().setLocation(required.getModuleJar());
    if (!hasLibraries) {
      hasLibraries=true;
    }
  }
  for (Iterator iter=module.getLibJars().iterator(); iter.hasNext(); ) {
    File file=(File)iter.next();
    classpath.createPathElement().setLocation(file);
    if (!hasLibraries) {
      hasLibraries=true;
    }
  }
  boolean inEclipse=true;
  if (hasLibraries && inEclipse) {
    javac.setFork(true);
  }
  classpath.createPathElement().setLocation(classesDir);
  javac.setClasspath(classpath);
  javac.setDestdir(classesDir);
  if (!classesDir.mkdirs()) {
    errors.add("String_Node_Str");
    return false;
  }
  try {
    return executeTask(javac);
  }
 catch (  BuildException e) {
    String args="String_Node_Str" + Arrays.asList(javac.getCurrentCompilerArgs());
    errors.add("String_Node_Str" + module.toLongString() + args+ "String_Node_Str"+ Util.renderException(e));
    return false;
  }
 finally {
    javac.init();
  }
}

Fixed version (ground truth):
protected boolean compile(Module module,File classesDir,List errors){
  Javac javac=new Javac();
  setupTask(javac,"String_Node_Str");
  Path path=new Path(project);
  for (Iterator iter=module.getSrcDirs().iterator(); iter.hasNext(); ) {
    File file=(File)iter.next();
    path.createPathElement().setLocation(file);
  }
  javac.setSrcdir(path);
  path=null;
  Path classpath=new Path(project);
  boolean hasLibraries=false;
  for (Iterator iter=module.getRequired().iterator(); iter.hasNext(); ) {
    Module required=(Module)iter.next();
    classpath.createPathElement().setLocation(required.getModuleJar());
    if (!hasLibraries) {
      hasLibraries=true;
    }
  }
  for (Iterator iter=module.getLibJars().iterator(); iter.hasNext(); ) {
    File file=(File)iter.next();
    classpath.createPathElement().setLocation(file);
    if (!hasLibraries) {
      hasLibraries=true;
    }
  }
  boolean inEclipse=true;
  if (hasLibraries && inEclipse) {
    javac.setFork(true);
  }
  classpath.createPathElement().setLocation(classesDir);
  javac.setClasspath(classpath);
  javac.setDestdir(classesDir);
  if (!classesDir.mkdirs()) {
    errors.add("String_Node_Str");
    return false;
  }
  try {
    return executeTask(javac);
  }
 catch (  BuildException e) {
    String args="String_Node_Str" + Arrays.asList(javac.getCurrentCompilerArgs());
    errors.add("String_Node_Str" + module.toLongString() + args+ "String_Node_Str"+ Util.renderException(e));
    return false;
  }
 finally {
    javac.init();
  }
}
Program: 9723
Project: 9723
Buggy source:
/** 
 * @see org.aspectj.internal.tools.ant.taskdefs.Builder#copyFiles(File,File,String,String,boolean)
 */
protected boolean copyFiles(File fromDir,File toDir,String includes,String excludes,boolean filter){
  Copy copy=makeCopyTask(filter);
  copy.setTodir(toDir);
  FileSet fileset=new FileSet();
  fileset.setDir(fromDir);
  if (null != includes) {
    fileset.setIncludes(includes);
  }
  if (null != excludes) {
    fileset.setExcludes(excludes);
  }
  copy.addFileset(fileset);
  executeTask(copy);
  return false;
}

Fixed version (ground truth):
/** 
 * (Filters set in project.)
 * @see org.aspectj.internal.tools.ant.taskdefs.Builder#copyFiles(File,File,String,String,boolean)
 */
protected boolean copyFiles(File fromDir,File toDir,String includes,String excludes,boolean filter){
  Copy copy=makeCopyTask(filter);
  copy.setTodir(toDir);
  FileSet fileset=new FileSet();
  fileset.setDir(fromDir);
  if (null != includes) {
    fileset.setIncludes(includes);
  }
  if (null != excludes) {
    fileset.setExcludes(excludes);
  }
  copy.addFileset(fileset);
  executeTask(copy);
  return false;
}
Program: 9724
Project: 9724
Buggy source:
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  resolveOnType(classScope);
  if (ignoreFurtherInvestigation)   return;
  if (onTypeBinding.isInterface()) {
    ignoreFurtherInvestigation=true;
    return;
  }
  if (onTypeBinding.isNestedType()) {
    classScope.problemReporter().signalError(sourceStart,sourceEnd,"String_Node_Str");
    ignoreFurtherInvestigation=true;
    return;
  }
  ResolvedTypeX declaringTypeX=world.fromEclipse(onTypeBinding);
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember bindingAsMember=world.makeResolvedMember(binding);
  ResolvedMember signature=new ResolvedMember(Member.CONSTRUCTOR,declaringTypeX,declaredModifiers,ResolvedTypeX.VOID,"String_Node_Str",bindingAsMember.getParameterTypes());
  ResolvedMember syntheticInterMember=AjcMemberMaker.interConstructor(declaringTypeX,signature,aspectType);
  NewConstructorTypeMunger myMunger=new NewConstructorTypeMunger(signature,syntheticInterMember,null,null);
  this.munger=myMunger;
  this.selector=binding.selector=NameMangler.postIntroducedConstructor(EclipseWorld.fromBinding(binding.declaringClass),declaringTypeX).toCharArray();
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}

Fixed version (ground truth):
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  resolveOnType(classScope);
  if (ignoreFurtherInvestigation)   return;
  if (onTypeBinding.isInterface()) {
    ignoreFurtherInvestigation=true;
    return;
  }
  if (onTypeBinding.isNestedType()) {
    classScope.problemReporter().signalError(sourceStart,sourceEnd,"String_Node_Str");
    ignoreFurtherInvestigation=true;
    return;
  }
  ResolvedTypeX declaringTypeX=world.fromEclipse(onTypeBinding);
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember bindingAsMember=world.makeResolvedMember(binding);
  ResolvedMember signature=new ResolvedMember(Member.CONSTRUCTOR,declaringTypeX,declaredModifiers,ResolvedTypeX.VOID,"String_Node_Str",bindingAsMember.getParameterTypes());
  ResolvedMember syntheticInterMember=AjcMemberMaker.interConstructor(declaringTypeX,signature,aspectType);
  NewConstructorTypeMunger myMunger=new NewConstructorTypeMunger(signature,syntheticInterMember,null,null);
  setMunger(myMunger);
  this.selector=binding.selector=NameMangler.postIntroducedConstructor(EclipseWorld.fromBinding(binding.declaringClass),declaringTypeX).toCharArray();
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}
Program: 9725
Project: 9725
Buggy source:
protected int generateInfoAttributes(ClassFile classFile){
  munger.getSignature().setPosition(sourceStart,sourceEnd);
  List l;
  ;
  Shadow.Kind kind=getShadowKindForBody();
  if (kind != null) {
    l=makeEffectiveSignatureAttribute(munger.getSignature(),kind,true);
  }
 else {
    l=new ArrayList(0);
  }
  return classFile.generateMethodInfoAttribute(binding,l);
}

Fixed version (ground truth):
protected int generateInfoAttributes(ClassFile classFile){
  List l;
  ;
  Shadow.Kind kind=getShadowKindForBody();
  if (kind != null) {
    l=makeEffectiveSignatureAttribute(munger.getSignature(),kind,true);
  }
 else {
    l=new ArrayList(0);
  }
  return classFile.generateMethodInfoAttribute(binding,l);
}
Program: 9726
Project: 9726
Buggy source:
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  resolveOnType(classScope);
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  if (ignoreFurtherInvestigation)   return;
  if (!Modifier.isStatic(declaredModifiers)) {
    super.binding.parameters=new TypeBinding[]{onTypeBinding};
    this.arguments=new Argument[]{AstUtil.makeFinalArgument("String_Node_Str".toCharArray(),onTypeBinding)};
  }
  ResolvedMember sig=new ResolvedMember(Member.FIELD,EclipseWorld.fromBinding(onTypeBinding),declaredModifiers,EclipseWorld.fromBinding(binding.returnType),new String(declaredSelector),TypeX.NONE);
  NewFieldTypeMunger myMunger=new NewFieldTypeMunger(sig,null);
  this.munger=myMunger;
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember me=myMunger.getInitMethod(aspectType);
  this.selector=binding.selector=me.getName().toCharArray();
  this.binding.returnType=TypeBinding.VoidBinding;
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}

Fixed version (ground truth):
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  resolveOnType(classScope);
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  if (ignoreFurtherInvestigation)   return;
  if (!Modifier.isStatic(declaredModifiers)) {
    super.binding.parameters=new TypeBinding[]{onTypeBinding};
    this.arguments=new Argument[]{AstUtil.makeFinalArgument("String_Node_Str".toCharArray(),onTypeBinding)};
  }
  ResolvedMember sig=new ResolvedMember(Member.FIELD,EclipseWorld.fromBinding(onTypeBinding),declaredModifiers,EclipseWorld.fromBinding(binding.returnType),new String(declaredSelector),TypeX.NONE);
  NewFieldTypeMunger myMunger=new NewFieldTypeMunger(sig,null);
  setMunger(myMunger);
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember me=myMunger.getInitMethod(aspectType);
  this.selector=binding.selector=me.getName().toCharArray();
  this.binding.returnType=TypeBinding.VoidBinding;
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}
Program: 9727
Project: 9727
Buggy source:
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  resolveOnType(classScope);
  if (ignoreFurtherInvestigation)   return;
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  ResolvedMember sig=new ResolvedMember(Member.METHOD,EclipseWorld.fromBinding(onTypeBinding),declaredModifiers,EclipseWorld.fromBinding(binding.returnType),new String(declaredSelector),EclipseWorld.fromBindings(binding.parameters));
  NewMethodTypeMunger myMunger=new NewMethodTypeMunger(sig,null);
  this.munger=myMunger;
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember me=myMunger.getDispatchMethod(aspectType);
  this.selector=binding.selector=me.getName().toCharArray();
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}

Fixed version (ground truth):
public void build(ClassScope classScope,CrosscuttingMembers xcut){
  EclipseWorld world=EclipseWorld.fromScopeLookupEnvironment(classScope);
  resolveOnType(classScope);
  if (ignoreFurtherInvestigation)   return;
  binding=classScope.referenceContext.binding.resolveTypesFor(binding);
  ResolvedMember sig=new ResolvedMember(Member.METHOD,EclipseWorld.fromBinding(onTypeBinding),declaredModifiers,EclipseWorld.fromBinding(binding.returnType),new String(declaredSelector),EclipseWorld.fromBindings(binding.parameters));
  NewMethodTypeMunger myMunger=new NewMethodTypeMunger(sig,null);
  setMunger(myMunger);
  ResolvedTypeX aspectType=world.fromEclipse(classScope.referenceContext.binding);
  ResolvedMember me=myMunger.getDispatchMethod(aspectType);
  this.selector=binding.selector=me.getName().toCharArray();
  xcut.addTypeMunger(new EclipseTypeMunger(myMunger,aspectType,this));
}
Program: 9728
Project: 9728
Buggy source:
public void checkPointcutDeclarations(){
  ResolvedMember[] pointcuts=getDeclaredPointcuts();
  for (int i=0, len=pointcuts.length; i < len; i++) {
    if (pointcuts[i].isAbstract()) {
      if (!this.isAspect()) {
        MessageUtil.error("String_Node_Str" + pointcuts[i].getName(),pointcuts[i].getSourceLocation());
      }
 else       if (!this.isAbstract()) {
        MessageUtil.error("String_Node_Str" + pointcuts[i].getName(),pointcuts[i].getSourceLocation());
      }
    }
    for (int j=i + 1; j < len; j++) {
      if (pointcuts[i].getName().equals(pointcuts[j].getName())) {
        eclipseWorld().getMessageHandler().handleMessage(MessageUtil.error("String_Node_Str" + pointcuts[j].getName(),pointcuts[j].getSourceLocation()));
      }
    }
  }
}

Fixed version (ground truth):
public void checkPointcutDeclarations(){
  ResolvedMember[] pointcuts=getDeclaredPointcuts();
  for (int i=0, len=pointcuts.length; i < len; i++) {
    if (pointcuts[i].isAbstract()) {
      if (!this.isAspect()) {
        MessageUtil.error("String_Node_Str" + pointcuts[i].getName(),pointcuts[i].getSourceLocation());
      }
 else       if (!this.isAbstract()) {
        MessageUtil.error("String_Node_Str" + pointcuts[i].getName(),pointcuts[i].getSourceLocation());
      }
    }
    for (int j=i + 1; j < len; j++) {
      if (pointcuts[i].getName().equals(pointcuts[j].getName())) {
        eclipseWorld().getMessageHandler().handleMessage(MessageUtil.error("String_Node_Str" + pointcuts[j].getName(),pointcuts[j].getSourceLocation()));
      }
    }
  }
  if (!isAspect())   return;
}
Program: 9729
Project: 9729
Buggy source:
private int compareMemberPrecedence(ResolvedMember m1,ResolvedMember m2){
  if (!m1.getReturnType().equals(m2.getReturnType()))   return 0;
  if (Modifier.isAbstract(m1.getModifiers()))   return -1;
  if (Modifier.isAbstract(m2.getModifiers()))   return +1;
  if (m1.getDeclaringType().equals(m2.getDeclaringType()))   return 0;
  ResolvedTypeX t1=m1.getDeclaringType().resolve(world);
  ResolvedTypeX t2=m2.getDeclaringType().resolve(world);
  if (t1.isAssignableFrom(t2)) {
    checkVisibility(m1.getModifiers(),m2.getModifiers());
    return -1;
  }
  if (t2.isAssignableFrom(t1)) {
    checkVisibility(m2.getModifiers(),m1.getModifiers());
    return +1;
  }
  return 0;
}

Fixed version (ground truth):
private int compareMemberPrecedence(ResolvedMember m1,ResolvedMember m2){
  if (Modifier.isAbstract(m1.getModifiers()))   return -1;
  if (Modifier.isAbstract(m2.getModifiers()))   return +1;
  if (m1.getDeclaringType().equals(m2.getDeclaringType()))   return 0;
  ResolvedTypeX t1=m1.getDeclaringType().resolve(world);
  ResolvedTypeX t2=m2.getDeclaringType().resolve(world);
  if (t1.isAssignableFrom(t2)) {
    return -1;
  }
  if (t2.isAssignableFrom(t1)) {
    return +1;
  }
  return 0;
}
Program: 9730
Project: 9730
Buggy source:
private boolean compareToExistingMembers(ConcreteTypeMunger munger,Iterator existingMembers){
  ResolvedMember sig=munger.getSignature();
  while (existingMembers.hasNext()) {
    ResolvedMember existingMember=(ResolvedMember)existingMembers.next();
    if (conflictingSignature(existingMember,munger.getSignature())) {
      if (isVisible(existingMember.getModifiers(),this,munger.getAspectType())) {
        int c=compareMemberPrecedence(sig,existingMember);
        if (c < 0)         return false;
 else         if (c > 0) {
          continue;
        }
 else {
          if (this instanceof BcelObjectType)           return false;
          getWorld().getMessageHandler().handleMessage(MessageUtil.error("String_Node_Str" + munger.getAspectType() + "String_Node_Str"+ existingMember,munger.getSourceLocation()));
        }
      }
 else {
      }
    }
  }
  return true;
}

Fixed version (ground truth):
private boolean compareToExistingMembers(ConcreteTypeMunger munger,Iterator existingMembers){
  ResolvedMember sig=munger.getSignature();
  while (existingMembers.hasNext()) {
    ResolvedMember existingMember=(ResolvedMember)existingMembers.next();
    if (conflictingSignature(existingMember,munger.getSignature())) {
      if (isVisible(existingMember.getModifiers(),this,munger.getAspectType())) {
        int c=compareMemberPrecedence(sig,existingMember);
        if (c < 0) {
          checkLegalOverride(existingMember,munger.getSignature());
          return false;
        }
 else         if (c > 0) {
          checkLegalOverride(munger.getSignature(),existingMember);
          continue;
        }
 else {
          if (this instanceof BcelObjectType)           return false;
          getWorld().getMessageHandler().handleMessage(MessageUtil.error("String_Node_Str" + munger.getAspectType() + "String_Node_Str"+ existingMember,munger.getSourceLocation()));
        }
      }
 else {
      }
    }
  }
  return true;
}
Program: 9732
Project: 9732
Buggy source:
/** 
 * returns an iterator through all of the pointcuts of this type, in order for checking from JVM spec 2ed 5.4.3.2 (as for fields).  This means that the order is <ul><li> pointcuts from current class </li> <li> recur into direct superinterfaces </li> <li> recur into superclass </li> </ul> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
 */
private Iterator getPointcuts(){
  final Iterators.Filter dupFilter=Iterators.dupFilter();
  Iterators.Getter typeGetter=new Iterators.Getter(){
    public Iterator get(    Object o){
      return dupFilter.filter(((ResolvedTypeX)o).getDirectSupertypes());
    }
  }
;
  Iterators.Getter pointcutGetter=new Iterators.Getter(){
    public Iterator get(    Object o){
      return Iterators.array(((ResolvedTypeX)o).getDeclaredPointcuts());
    }
  }
;
  return Iterators.mapOver(Iterators.recur(this,typeGetter),pointcutGetter);
}

Fixed version (ground truth):
/** 
 * returns an iterator through all of the pointcuts of this type, in order for checking from JVM spec 2ed 5.4.3.2 (as for fields).  This means that the order is <ul><li> pointcuts from current class </li> <li> recur into direct superinterfaces </li> <li> recur into superclass </li> </ul> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
 */
public Iterator getPointcuts(){
  final Iterators.Filter dupFilter=Iterators.dupFilter();
  Iterators.Getter typeGetter=new Iterators.Getter(){
    public Iterator get(    Object o){
      return dupFilter.filter(((ResolvedTypeX)o).getDirectSupertypes());
    }
  }
;
  Iterators.Getter pointcutGetter=new Iterators.Getter(){
    public Iterator get(    Object o){
      return Iterators.array(((ResolvedTypeX)o).getDeclaredPointcuts());
    }
  }
;
  return Iterators.mapOver(Iterators.recur(this,typeGetter),pointcutGetter);
}
Program: 9733
Project: 9733
Buggy source:
private AjAttribute makeAttribute(EclipseWorld world){
  if (explicitConstructorCall != null) {
    MethodBinding explicitConstructor=explicitConstructorCall.binding;
    if (explicitConstructor.alwaysNeedsAccessMethod()) {
      explicitConstructor=explicitConstructor.getAccessMethod();
    }
    ((NewConstructorTypeMunger)munger).setExplicitConstructor(world.makeResolvedMember(explicitConstructor));
  }
 else {
    ((NewConstructorTypeMunger)munger).setExplicitConstructor(new ResolvedMember(Member.CONSTRUCTOR,EclipseWorld.fromBinding(onTypeBinding.superclass()),0,ResolvedTypeX.VOID,"String_Node_Str",TypeX.NONE));
  }
  return new AjAttribute.TypeMunger(munger);
}

Fixed version (ground truth):
private AjAttribute makeAttribute(EclipseWorld world){
  if (explicitConstructorCall != null && !(explicitConstructorCall.binding instanceof ProblemMethodBinding)) {
    MethodBinding explicitConstructor=explicitConstructorCall.binding;
    if (explicitConstructor.alwaysNeedsAccessMethod()) {
      explicitConstructor=explicitConstructor.getAccessMethod();
    }
    ((NewConstructorTypeMunger)munger).setExplicitConstructor(world.makeResolvedMember(explicitConstructor));
  }
 else {
    ((NewConstructorTypeMunger)munger).setExplicitConstructor(new ResolvedMember(Member.CONSTRUCTOR,EclipseWorld.fromBinding(onTypeBinding.superclass()),0,ResolvedTypeX.VOID,"String_Node_Str",TypeX.NONE));
  }
  return new AjAttribute.TypeMunger(munger);
}
Program: 9734
Project: 9734
Buggy source:
public void generateCode(ClassScope classScope,ClassFile classFile){
  if (ignoreFurtherInvestigation) {
    System.err.println("String_Node_Str" + this);
    return;
  }
  classFile.extraAttributes.add(new EclipseAttributeAdapter(makeAttribute()));
  if (!Modifier.isAbstract(declaredModifiers)) {
    super.generateCode(classScope,classFile);
  }
  generateDispatchMethod(classScope,classFile);
}

Fixed version (ground truth):
public void generateCode(ClassScope classScope,ClassFile classFile){
  if (ignoreFurtherInvestigation) {
    return;
  }
  classFile.extraAttributes.add(new EclipseAttributeAdapter(makeAttribute()));
  if (!Modifier.isAbstract(declaredModifiers)) {
    super.generateCode(classScope,classFile);
  }
  generateDispatchMethod(classScope,classFile);
}