nus-yam/ex-repair huggingface dataset:
Program: 100045
Project: 100045
Buggy source:
private void computeFlowsTo(PointsToComputer ptoComputer,OrdinalSet<InstanceKeyAndState> basePToSet,IField field){
  for (  InstanceKeyAndState ikAndState : basePToSet) {
    ptoComputer.trackInstanceField(ikAndState,field,ptoComputer.forwInstKeyToFields);
  }
  ptoComputer.worklistLoop();
}

Fixed version (ground truth):
private void computeFlowsTo(PointsToComputer ptoComputer,OrdinalSet<InstanceKeyAndState> basePToSet){
}
Program: 100046
Project: 100046
Buggy source:
@Override public void visitAssign(AssignLabel label,Object dst){
  final PointerKey predPk=(PointerKey)dst;
  doTransition(curState,AssignBarLabel.noFilter(),new Function<State,Object>(){
    public Object apply(    State predPkState){
      PointerKeyAndState predPkAndState=new PointerKeyAndState(predPk,predPkState);
      if (findOrCreate(pkToTrackedSet,predPkAndState).addAll(trackedSet)) {
        addToTrackedPToWorklist(predPkAndState);
      }
      return null;
    }
  }
);
}

Fixed version (ground truth):
@Override public void visitAssign(AssignLabel label,Object dst){
  final PointerKey succPk=(PointerKey)dst;
  doTransition(curState,label,new Function<State,Object>(){
    public Object apply(    State nextState){
      h.propagate(new PointerKeyAndState(succPk,nextState));
      return null;
    }
  }
);
}
Program: 100047
Project: 100047
Buggy source:
private void drainAndCatch(BufferedInputStream s,ByteArrayOutputStream b) throws IOException {
  while (s.available() > 0) {
    byte[] data=new byte[s.available()];
    int nRead=s.read(data);
    b.write(data,0,nRead);
  }
}

Fixed version (ground truth):
private void drainAndCatch(BufferedInputStream s,ByteArrayOutputStream b) throws IOException {
  try {
    while (s.available() > 0) {
      byte[] data=new byte[s.available()];
      int nRead=s.read(data);
      b.write(data,0,nRead);
    }
  }
 catch (  IOException e) {
  }
}
Program: 100048
Project: 100048
Buggy source:
private void drainAndPrint(BufferedInputStream s,PrintStream p) throws IOException {
  while (s.available() > 0) {
    byte[] data=new byte[s.available()];
    s.read(data);
    p.print(new String(data));
  }
}

Fixed version (ground truth):
private void drainAndPrint(BufferedInputStream s,PrintStream p) throws IOException {
  try {
    while (s.available() > 0) {
      byte[] data=new byte[s.available()];
      s.read(data);
      p.print(new String(data));
    }
  }
 catch (  IOException e) {
  }
}
Program: 100049
Project: 100049
Buggy source:
public Iterator<? extends T> getReturnSites(T c){
  return delegate.getCallSites(c);
}

Fixed version (ground truth):
public Iterator<? extends T> getReturnSites(T c,P callee){
  return delegate.getCallSites(c,callee);
}
Program: 100050
Project: 100050
Buggy source:
public Iterator<? extends T> getCallSites(T r){
  return delegate.getReturnSites(r);
}

Fixed version (ground truth):
public Iterator<? extends T> getCallSites(T r,P callee){
  return delegate.getReturnSites(r,callee);
}
Program: 100051
Project: 100051
Buggy source:
/** 
 * @return the blocks in the supergraph that represents exit nodes forprocedure p
 */
T[] getExitsForProcedure(P procedure);

Fixed version (ground truth):
/** 
 * @return the blocks in the supergraph that represents exit nodes for procedure p
 */
T[] getExitsForProcedure(P procedure);
Program: 100052
Project: 100052
Buggy source:
/** 
 * @param call a "call" node in the supergraph
 * @return an Iterator of nodes that are normal (non-call) successors of thiscall. This should only apply to backwards problems, where we might have, say, a call and a goto flow into a return site.
 */
Iterator<T> getNormalSuccessors(T call);

Fixed version (ground truth):
/** 
 * @param call a "call" node in the supergraph
 * @return an Iterator of nodes that are normal (non-call) successors of this call. This should only apply tobackwards problems, where we might have, say, a call and a goto flow into a return site.
 */
Iterator<T> getNormalSuccessors(T call);
Program: 100053
Project: 100053
Buggy source:
/** 
 * @param call a "call" node in the supergraph
 * @return the corresponding return nodes. There may be many, because ofexceptional control flow.
 */
Iterator<? extends T> getReturnSites(T call);

Fixed version (ground truth):
/** 
 * @param call a "call" node in the supergraph
 * @param callee a "called" "procedure" in the supergraph.  if callee is null, answer return sites for which no callee was found.
 * @return the corresponding return nodes. There may be many, because of exceptional control flow.
 */
Iterator<? extends T> getReturnSites(T call,P callee);
Program: 100054
Project: 100054
Buggy source:
/** 
 * @param r a "return" node in the supergraph
 * @return the corresponding call nodes. There may be many.
 */
Iterator<? extends T> getCallSites(T r);

Fixed version (ground truth):
/** 
 * @param r a "return" node in the supergraph
 * @param callee a "called" "procedure" in the supergraph.  if callee is null, answer return sites for which no callee was found.
 * @return the corresponding call nodes. There may be many.
 */
Iterator<? extends T> getCallSites(T ret,P callee);
Program: 100055
Project: 100055
Buggy source:
/** 
 * @return the blocks in the supergraph that represents entry nodes forprocedure p
 */
T[] getEntriesForProcedure(P procedure);

Fixed version (ground truth):
/** 
 * @return the blocks in the supergraph that represents entry nodes for procedure p
 */
T[] getEntriesForProcedure(P procedure);
Program: 100056
Project: 100056
Buggy source:
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getReturnSites(Object object){
  if (object instanceof BasicBlockInContext) {
    return partialIPFG.getReturnSites((BasicBlockInContext)object);
  }
 else {
    CGNode n=nodeManager.getProcOfCollapsedNode(object);
    return new NonNullSingletonIterator<CollapsedNode>(nodeManager.getCollapsedExit(n));
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getReturnSites(Object object,CGNode callee){
  if (object instanceof BasicBlockInContext) {
    return partialIPFG.getReturnSites((BasicBlockInContext)object);
  }
 else {
    CGNode n=nodeManager.getProcOfCollapsedNode(object);
    return new NonNullSingletonIterator<CollapsedNode>(nodeManager.getCollapsedExit(n));
  }
}
Program: 100058
Project: 100058
Buggy source:
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getSuccNodes(Object N){
  if (N instanceof IBasicBlock) {
    Set<Object> xverse=outgoingTransverseEdges.get(N);
    if (xverse == null) {
      return partialIPFG.getSuccNodes((BasicBlockInContext)N);
    }
 else {
      return new CompoundIterator<Object>(partialIPFG.getSuccNodes((BasicBlockInContext)N),xverse.iterator());
    }
  }
 else {
    if (isEntry(N)) {
      Set<Object> result=HashSetFactory.make(4);
      CGNode n=nodeManager.getProcOfCollapsedNode(N);
      for (Iterator it=cg.getSuccNodes(n); it.hasNext(); ) {
        CGNode s=(CGNode)it.next();
        if (!noCollapse.contains(s)) {
          result.add(nodeManager.getCollapsedEntry(s));
        }
      }
      result.add(nodeManager.getCollapsedExit(n));
      Set<Object> xverse=outgoingTransverseEdges.get(N);
      if (xverse != null) {
        result.addAll(xverse);
      }
      return result.iterator();
    }
 else {
      CGNode n=nodeManager.getProcOfCollapsedNode(N);
      Object entry=nodeManager.getCollapsedEntry(n);
      HashSet<Object> result=HashSetFactory.make(4);
      for (Iterator it=getPredNodes(entry); it.hasNext(); ) {
        Object callSite=it.next();
        for (Iterator returnSites=getReturnSites(callSite); returnSites.hasNext(); ) {
          result.add(returnSites.next());
        }
      }
      return result.iterator();
    }
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getSuccNodes(Object N){
  if (N instanceof IBasicBlock) {
    Set<Object> xverse=outgoingTransverseEdges.get(N);
    if (xverse == null) {
      return partialIPFG.getSuccNodes((BasicBlockInContext)N);
    }
 else {
      return new CompoundIterator<Object>(partialIPFG.getSuccNodes((BasicBlockInContext)N),xverse.iterator());
    }
  }
 else {
    if (isEntry(N)) {
      Set<Object> result=HashSetFactory.make(4);
      CGNode n=nodeManager.getProcOfCollapsedNode(N);
      for (Iterator it=cg.getSuccNodes(n); it.hasNext(); ) {
        CGNode s=(CGNode)it.next();
        if (!noCollapse.contains(s)) {
          result.add(nodeManager.getCollapsedEntry(s));
        }
      }
      result.add(nodeManager.getCollapsedExit(n));
      Set<Object> xverse=outgoingTransverseEdges.get(N);
      if (xverse != null) {
        result.addAll(xverse);
      }
      return result.iterator();
    }
 else {
      CGNode n=nodeManager.getProcOfCollapsedNode(N);
      Object entry=nodeManager.getCollapsedEntry(n);
      HashSet<Object> result=HashSetFactory.make(4);
      for (Iterator it=getPredNodes(entry); it.hasNext(); ) {
        Object callSite=it.next();
        for (Iterator returnSites=getReturnSites(callSite,n); returnSites.hasNext(); ) {
          result.add(returnSites.next());
        }
      }
      return result.iterator();
    }
  }
}
Program: 100059
Project: 100059
Buggy source:
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getCallSites(Object object){
  if (object instanceof BasicBlockInContext) {
    return partialIPFG.getCallSites((BasicBlockInContext<ISSABasicBlock>)object);
  }
 else {
    CGNode n=nodeManager.getProcOfCollapsedNode(object);
    return new NonNullSingletonIterator<CollapsedNode>(nodeManager.getCollapsedEntry(n));
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public Iterator<? extends Object> getCallSites(Object object,CGNode callee){
  if (object instanceof BasicBlockInContext) {
    return partialIPFG.getCallSites((BasicBlockInContext<ISSABasicBlock>)object,callee);
  }
 else {
    CGNode n=nodeManager.getProcOfCollapsedNode(object);
    return new NonNullSingletonIterator<CollapsedNode>(nodeManager.getCollapsedEntry(n));
  }
}
Program: 100063
Project: 100063
Buggy source:
/** 
 * A debugging aid. TODO: move this elsewhere
 */
public static void clearSoftCaches(){
  float occupancy=1f - ((float)Runtime.getRuntime().freeMemory() / (float)Runtime.getRuntime().totalMemory());
  if (occupancy < OCCUPANCY_TRIGGER) {
    return;
  }
  if (getAnalysisCache() != null) {
    getAnalysisCache().getSSACache().wipe();
    getAnalysisCache().getCFGCache().wipe();
  }
  IClassHierarchy cha=getClassHierarchy();
  if (cha != null) {
    for (    IClass klass : cha) {
      if (klass instanceof ShrikeClass) {
        ShrikeClass c=(ShrikeClass)klass;
        c.clearSoftCaches();
      }
 else {
        for (Iterator it2=klass.getDeclaredMethods().iterator(); it2.hasNext(); ) {
          IMethod m=(IMethod)it2.next();
          if (m instanceof ShrikeCTMethod) {
            ((ShrikeCTMethod)m).clearCaches();
          }
        }
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * A debugging aid. TODO: move this elsewhere
 */
public static void clearSoftCaches(){
  float occupancy=1f - ((float)Runtime.getRuntime().freeMemory() / (float)Runtime.getRuntime().totalMemory());
  if (occupancy < OCCUPANCY_TRIGGER) {
    return;
  }
  AnalysisCache cache=getAnalysisCache();
  if (cache != null) {
    cache.getSSACache().wipe();
    cache.getCFGCache().wipe();
  }
  IClassHierarchy cha=getClassHierarchy();
  if (cha != null) {
    for (    IClass klass : cha) {
      if (klass instanceof ShrikeClass) {
        ShrikeClass c=(ShrikeClass)klass;
        c.clearSoftCaches();
      }
 else {
        for (Iterator it2=klass.getDeclaredMethods().iterator(); it2.hasNext(); ) {
          IMethod m=(IMethod)it2.next();
          if (m instanceof ShrikeCTMethod) {
            ((ShrikeCTMethod)m).clearCaches();
          }
        }
      }
    }
  }
}
Program: 100064
Project: 100064
Buggy source:
/** 
 * @return the IClass that represents the array element type, or null if theelement type is a primitive
 */
public IClass getElementClass(){
  TypeReference elementType=getReference().getArrayElementType();
  if (elementType.isPrimitiveType()) {
    return null;
  }
  return loader.lookupClass(elementType.getName());
}

Fixed version (ground truth):
/** 
 * @return the IClass that represents the array element type, or null if the element type is a primitive
 */
public IClass getElementClass(){
  TypeReference elementType=getReference().getArrayElementType();
  if (elementType.isPrimitiveType()) {
    return null;
  }
  return loader.lookupClass(elementType.getName());
}
Program: 100065
Project: 100065
Buggy source:
/** 
 * @return the IClass that represents the innermost array element type, ornull if the element type is a primitive
 */
public IClass getInnermostElementClass(){
  TypeReference elementType=getReference().getInnermostElementType();
  if (elementType.isPrimitiveType()) {
    return null;
  }
  return loader.lookupClass(elementType.getName());
}

Fixed version (ground truth):
/** 
 * @return the IClass that represents the innermost array element type, or null if the element type is a primitive
 */
public IClass getInnermostElementClass(){
  TypeReference elementType=getReference().getInnermostElementType();
  if (elementType.isPrimitiveType()) {
    return null;
  }
  return loader.lookupClass(elementType.getName());
}
Program: 100066
Project: 100066
Buggy source:
public Collection<IClass> getAllImplementedInterfaces(){
  HashSet<IClass> result=HashSetFactory.make(2);
  result.add(loader.lookupClass(TypeReference.array_interfaces[0]));
  result.add(loader.lookupClass(TypeReference.array_interfaces[1]));
  return result;
}

Fixed version (ground truth):
public Collection<IClass> getAllImplementedInterfaces(){
  HashSet<IClass> result=HashSetFactory.make(2);
  IClass klass=loader.lookupClass(TypeReference.array_interfaces[0]);
  if (klass != null) {
    result.add(klass);
  }
  klass=loader.lookupClass(TypeReference.array_interfaces[1]);
  if (klass != null) {
    result.add(klass);
  }
  return result;
}
Program: 100067
Project: 100067
Buggy source:
public Iterator<PointerKey> getReadsOfInstanceField(PointerKey pk,IField f){
  if (f == ArrayContents.v()) {
    return getArrayReads(pk);
  }
  Collection<MemoryAccess> reads=mam.getFieldReads(pk,f);
  for (  MemoryAccess a : reads) {
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> readInto=new ArrayList<PointerKey>();
  for (  MemoryAccess a : reads) {
    IR ir=a.getNode().getIR();
    SSAGetInstruction s=(SSAGetInstruction)ir.getInstructions()[a.getInstructionIndex()];
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getDef());
    readInto.add(r);
  }
  return readInto.iterator();
}

Fixed version (ground truth):
public Iterator<PointerKey> getReadsOfInstanceField(PointerKey pk,IField f){
  if (f == ArrayContents.v()) {
    return getArrayReads(pk);
  }
  Collection<MemoryAccess> reads=mam.getFieldReads(pk,f);
  for (  MemoryAccess a : reads) {
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> readInto=new ArrayList<PointerKey>();
  for (  MemoryAccess a : reads) {
    IR ir=a.getNode().getIR();
    SSAGetInstruction s=(SSAGetInstruction)ir.getInstructions()[a.getInstructionIndex()];
    if (s == null) {
      continue;
    }
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getDef());
    readInto.add(r);
  }
  return readInto.iterator();
}
Program: 100068
Project: 100068
Buggy source:
protected Iterator<PointerKey> getArrayReads(PointerKey arrayRef){
  Collection<MemoryAccess> arrayReads=mam.getArrayReads(arrayRef);
  for (Iterator<MemoryAccess> it=arrayReads.iterator(); it.hasNext(); ) {
    MemoryAccess a=it.next();
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> read=new ArrayList<PointerKey>();
  for (Iterator<MemoryAccess> it=arrayReads.iterator(); it.hasNext(); ) {
    MemoryAccess a=it.next();
    IR ir=a.getNode().getIR();
    SSAArrayLoadInstruction s=(SSAArrayLoadInstruction)ir.getInstructions()[a.getInstructionIndex()];
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getDef());
    read.add(r);
  }
  return read.iterator();
}

Fixed version (ground truth):
protected Iterator<PointerKey> getArrayReads(PointerKey arrayRef){
  Collection<MemoryAccess> arrayReads=mam.getArrayReads(arrayRef);
  for (Iterator<MemoryAccess> it=arrayReads.iterator(); it.hasNext(); ) {
    MemoryAccess a=it.next();
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> read=new ArrayList<PointerKey>();
  for (Iterator<MemoryAccess> it=arrayReads.iterator(); it.hasNext(); ) {
    MemoryAccess a=it.next();
    IR ir=a.getNode().getIR();
    SSAArrayLoadInstruction s=(SSAArrayLoadInstruction)ir.getInstructions()[a.getInstructionIndex()];
    if (s == null) {
      continue;
    }
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getDef());
    read.add(r);
  }
  return read.iterator();
}
Program: 100069
Project: 100069
Buggy source:
private void init(Graph<T> G,Iterator<? extends T> nodes){
  this.G=G;
  while (nodes.hasNext()) {
    T o=nodes.next();
    if (!visited.contains(o)) {
      Q.add(o);
      visited.add(o);
    }
  }
  index=0;
  T current=Q.get(0);
  visitChildren(current);
}

Fixed version (ground truth):
private void init(Graph<T> G,Iterator<? extends T> nodes){
  this.G=G;
  while (nodes.hasNext()) {
    T o=nodes.next();
    if (!visited.contains(o)) {
      Q.add(o);
      visited.add(o);
    }
  }
  index=0;
  if (Q.size() > 0) {
    T current=Q.get(0);
    visitChildren(current);
  }
}
Program: 100070
Project: 100070
Buggy source:
public boolean understands(CGNode node){
  if (node == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (!(node.getContext() instanceof JavaTypeContext))   return false;
  return node.getMethod().getReference().equals(CLASS_NEW_INSTANCE_REF);
}

Fixed version (ground truth):
public boolean understands(CGNode node){
  if (node == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (!(node.getContext() instanceof JavaTypeContext)) {
    return false;
  }
  return node.getMethod().getReference().equals(CLASS_NEW_INSTANCE_REF);
}
Program: 100071
Project: 100071
Buggy source:
public Context getCalleeTarget(CGNode caller,CallSiteReference site,IMethod callee,InstanceKey receiver){
  if (callee.getReference().equals(ClassNewInstanceContextInterpreter.CLASS_NEW_INSTANCE_REF) && isTypeConstant(receiver)) {
    IClass c=(IClass)((ConstantKey)receiver).getValue();
    return new JavaTypeContext(new PointType(c));
  }
  return null;
}

Fixed version (ground truth):
public Context getCalleeTarget(CGNode caller,CallSiteReference site,IMethod callee,InstanceKey receiver){
  if (callee.getReference().equals(ClassNewInstanceContextInterpreter.CLASS_NEW_INSTANCE_REF) && isTypeConstant(receiver)) {
    IClass c=(IClass)((ConstantKey)receiver).getValue();
    if (!c.isAbstract() && !c.isInterface()) {
      return new JavaTypeContext(new PointType(c));
    }
  }
  return null;
}
Program: 100072
Project: 100072
Buggy source:
/** 
 * Set up a method summary which allocates and returns an instance of concrete type T.
 * @param T
 */
private void addStatementsForConcreteType(final TypeReference T){
  int alloc=addStatementsForConcreteSimpleType(T);
  if (alloc == -1) {
    return;
  }
  if (T.isArrayType()) {
    MethodReference init=MethodReference.findOrCreate(T,MethodReference.initAtom,MethodReference.defaultInitDesc);
    CallSiteReference site=CallSiteReference.make(getCallSiteForType(T),init,IInvokeInstruction.Dispatch.SPECIAL);
    int[] params=new int[1];
    params[0]=alloc;
    int exc=getExceptionsForType(T);
    SSAInvokeInstruction s=new SSAInvokeInstruction(params,exc,site);
    calls.add(s);
    allInstructions.add(s);
  }
 else {
  }
}

Fixed version (ground truth):
/** 
 * Set up a method summary which allocates and returns an instance of concrete type T.
 * @param T
 */
private void addStatementsForConcreteType(final TypeReference T){
  int alloc=addStatementsForConcreteSimpleType(T);
  if (alloc == -1) {
    return;
  }
  if (T.isArrayType()) {
    MethodReference init=MethodReference.findOrCreate(T,MethodReference.initAtom,MethodReference.defaultInitDesc);
    CallSiteReference site=CallSiteReference.make(getCallSiteForType(T),init,IInvokeInstruction.Dispatch.SPECIAL);
    int[] params=new int[1];
    params[0]=alloc;
    int exc=getExceptionsForType(T);
    SSAInvokeInstruction s=new SSAInvokeInstruction(params,exc,site);
    calls.add(s);
    allInstructions.add(s);
  }
}
Program: 100073
Project: 100073
Buggy source:
private void addStatementsForSetOfTypes(Iterator it){
  if (!it.hasNext()) {
    SSAReturnInstruction r=new SSAReturnInstruction(nextLocal,false);
    allInstructions.add(r);
  }
  for (; it.hasNext(); ) {
    IClass klass=(IClass)it.next();
    TypeReference T=klass.getReference();
    if (klass.isAbstract() || typesAllocated.contains(T)) {
      continue;
    }
    typesAllocated.add(T);
    int i=getLocalForType(T);
    NewSiteReference ref=NewSiteReference.make(getNewSiteForType(T),T);
    SSANewInstruction a=null;
    if (T.isArrayType()) {
      int[] sizes=new int[T.getDimensionality()];
      initValueNumberForConstantOne();
      Arrays.fill(sizes,valueNumberForConstantOne);
      a=new SSANewInstruction(i,ref,sizes);
    }
 else {
      a=new SSANewInstruction(i,ref);
    }
    allocations.add(a);
    allInstructions.add(a);
    SSAReturnInstruction r=new SSAReturnInstruction(i,false);
    allInstructions.add(r);
    MethodReference init=MethodReference.findOrCreate(T,MethodReference.initAtom,MethodReference.defaultInitDesc);
    CallSiteReference site=CallSiteReference.make(getCallSiteForType(T),init,IInvokeInstruction.Dispatch.SPECIAL);
    int[] params=new int[1];
    params[0]=i;
    SSAInvokeInstruction s=new SSAInvokeInstruction(params,getExceptionsForType(T),site);
    calls.add(s);
    allInstructions.add(s);
  }
}

Fixed version (ground truth):
private void addStatementsForSetOfTypes(Iterator it){
  if (!it.hasNext()) {
    SSAReturnInstruction r=new SSAReturnInstruction(nextLocal,false);
    allInstructions.add(r);
  }
  for (; it.hasNext(); ) {
    IClass klass=(IClass)it.next();
    TypeReference T=klass.getReference();
    if (klass.isAbstract() || klass.isInterface() || typesAllocated.contains(T)) {
      continue;
    }
    typesAllocated.add(T);
    int i=getLocalForType(T);
    NewSiteReference ref=NewSiteReference.make(getNewSiteForType(T),T);
    SSANewInstruction a=null;
    if (T.isArrayType()) {
      int[] sizes=new int[T.getDimensionality()];
      initValueNumberForConstantOne();
      Arrays.fill(sizes,valueNumberForConstantOne);
      a=new SSANewInstruction(i,ref,sizes);
    }
 else {
      a=new SSANewInstruction(i,ref);
    }
    allocations.add(a);
    allInstructions.add(a);
    SSAReturnInstruction r=new SSAReturnInstruction(i,false);
    allInstructions.add(r);
    MethodReference init=MethodReference.findOrCreate(T,MethodReference.initAtom,MethodReference.defaultInitDesc);
    CallSiteReference site=CallSiteReference.make(getCallSiteForType(T),init,IInvokeInstruction.Dispatch.SPECIAL);
    int[] params=new int[1];
    params[0]=i;
    SSAInvokeInstruction s=new SSAInvokeInstruction(params,getExceptionsForType(T),site);
    calls.add(s);
    allInstructions.add(s);
  }
}
Program: 100074
Project: 100074
Buggy source:
/** 
 * Private constructor ... only for internal use.
 * @throws IllegalArgumentException if type is null
 */
public PointType(IClass type){
  if (type == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.type=type;
  if (Assertions.verifyAssertions) {
    Assertions._assert(type.getReference().isReferenceType());
  }
}

Fixed version (ground truth):
/** 
 * Private constructor ... only for internal use.
 * @throws IllegalArgumentException if type is null
 */
public PointType(IClass type){
  if (type == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.type=type;
  if (Assertions.verifyAssertions) {
    Assertions._assert(type.getReference().isReferenceType());
    Assertions._assert(!type.isInterface());
  }
}
Program: 100075
Project: 100075
Buggy source:
public void map(Object astType,CAstType castType){
  fMap.put(astType,castType);
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public void map(Object astType,CAstType castType){
  fMap.put(astType,castType);
}
Program: 100078
Project: 100078
Buggy source:
public Iterator<PointerKey> getWritesToInstanceField(PointerKey pk,IField f){
  if (f == ArrayContents.v()) {
    return getArrayWrites(pk);
  }
  Collection<MemoryAccess> writes=mam.getFieldWrites(pk,f);
  for (  MemoryAccess a : writes) {
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> written=new ArrayList<PointerKey>();
  for (  MemoryAccess a : writes) {
    IR ir=a.getNode().getIR();
    SSAPutInstruction s=(SSAPutInstruction)ir.getInstructions()[a.getInstructionIndex()];
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getVal());
    written.add(r);
  }
  return written.iterator();
}

Fixed version (ground truth):
public Iterator<PointerKey> getWritesToInstanceField(PointerKey pk,IField f){
  if (f == ArrayContents.v()) {
    return getArrayWrites(pk);
  }
  Collection<MemoryAccess> writes=mam.getFieldWrites(pk,f);
  for (  MemoryAccess a : writes) {
    addSubgraphForNode(a.getNode());
  }
  ArrayList<PointerKey> written=new ArrayList<PointerKey>();
  for (  MemoryAccess a : writes) {
    IR ir=a.getNode().getIR();
    SSAPutInstruction s=(SSAPutInstruction)ir.getInstructions()[a.getInstructionIndex()];
    if (s == null) {
      continue;
    }
    PointerKey r=heapModel.getPointerKeyForLocal(a.getNode(),s.getVal());
    written.add(r);
  }
  return written.iterator();
}
Program: 100079
Project: 100079
Buggy source:
@Override protected MachineState makeEdgeVariable(BasicBlock from,BasicBlock to){
  if (Assertions.verifyAssertions) {
    Assertions._assert(from != null);
    Assertions._assert(to != null);
  }
  MachineState result=new MachineState(71167 * (from.hashCode() + to.hashCode()),from);
  return result;
}

Fixed version (ground truth):
@Override protected MachineState makeEdgeVariable(BasicBlock from,BasicBlock to){
  if (Assertions.verifyAssertions) {
    Assertions._assert(from != null);
    Assertions._assert(to != null);
  }
  MachineState result=new MachineState(71167 * from.hashCode() + to.hashCode(),from);
  return result;
}
Program: 100081
Project: 100081
Buggy source:
/** 
 * Create nodes corresponding to <ul> <li> phi instructions <li> getCaughtExceptions </ul>
 */
private void createSpecialStatements(IR ir,Collection<SSAInstruction> visited){
  for (Iterator<SSAInstruction> it=ir.iterateAllInstructions(); it.hasNext(); ) {
    SSAInstruction s=it.next();
    if (s != null && !visited.contains(s)) {
      visited.add(s);
      if (s instanceof SSAPhiInstruction) {
        delegate.addNode(new PhiStatement(node,(SSAPhiInstruction)s));
      }
 else       if (s instanceof SSAGetCaughtExceptionInstruction) {
        delegate.addNode(new GetCaughtExceptionStatement(node,(SSAGetCaughtExceptionInstruction)s));
      }
 else       if (s instanceof SSAPiInstruction) {
        delegate.addNode(new PiStatement(node,(SSAPiInstruction)s));
      }
 else {
        Assertions.UNREACHABLE(s.toString());
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Create nodes corresponding to <ul> <li> phi instructions <li> getCaughtExceptions </ul>
 */
private void createSpecialStatements(IR ir){
  for (Iterator<SSAInstruction> it=ir.iterateAllInstructions(); it.hasNext(); ) {
    SSAInstruction s=it.next();
    if (s instanceof SSAPhiInstruction) {
      delegate.addNode(new PhiStatement(node,(SSAPhiInstruction)s));
    }
 else     if (s instanceof SSAGetCaughtExceptionInstruction) {
      delegate.addNode(new GetCaughtExceptionStatement(node,(SSAGetCaughtExceptionInstruction)s));
    }
 else     if (s instanceof SSAPiInstruction) {
      delegate.addNode(new PiStatement(node,(SSAPiInstruction)s));
    }
  }
}
Program: 100082
Project: 100082
Buggy source:
/** 
 * Create nodes in the graph corresponding to "normal" (bytecode) instructions
 */
private Collection<SSAInstruction> createNormalStatements(IR ir,Map<CGNode,OrdinalSet<PointerKey>> ref){
  Collection<SSAInstruction> visited=HashSetFactory.make();
  SSAInstruction[] instructions=ir.getInstructions();
  for (int i=0; i < instructions.length; i++) {
    SSAInstruction s=instructions[i];
    if (s instanceof SSAGetCaughtExceptionInstruction) {
      continue;
    }
    if (s != null) {
      delegate.addNode(new NormalStatement(node,i));
      visited.add(s);
    }
    if (s instanceof SSAAbstractInvokeInstruction) {
      addParamPassingStatements(i,ref,ir);
    }
  }
  return visited;
}

Fixed version (ground truth):
/** 
 * Create nodes in the graph corresponding to "normal" (bytecode) instructions
 */
private void createNormalStatements(IR ir,Map<CGNode,OrdinalSet<PointerKey>> ref){
  SSAInstruction[] instructions=ir.getInstructions();
  for (int i=0; i < instructions.length; i++) {
    SSAInstruction s=instructions[i];
    if (s instanceof SSAGetCaughtExceptionInstruction) {
      continue;
    }
    if (s != null) {
      delegate.addNode(new NormalStatement(node,i));
    }
    if (s instanceof SSAAbstractInvokeInstruction) {
      addParamPassingStatements(i,ref,ir);
    }
  }
}
Program: 100083
Project: 100083
Buggy source:
/** 
 * Create all nodes in this PDG. Each node is a Statement.
 */
private void createNodes(Map<CGNode,OrdinalSet<PointerKey>> ref,ControlDependenceOptions cOptions,IR ir){
  if (ir != null) {
    Collection<SSAInstruction> visited=createNormalStatements(ir,ref);
    createSpecialStatements(ir,visited);
  }
  createCalleeParams(ref);
  createReturnStatements();
  delegate.addNode(new MethodEntryStatement(node));
  delegate.addNode(new MethodExitStatement(node));
}

Fixed version (ground truth):
/** 
 * Create all nodes in this PDG. Each node is a Statement.
 */
private void createNodes(Map<CGNode,OrdinalSet<PointerKey>> ref,ControlDependenceOptions cOptions,IR ir){
  if (ir != null) {
    createNormalStatements(ir,ref);
    createSpecialStatements(ir);
  }
  createCalleeParams(ref);
  createReturnStatements();
  delegate.addNode(new MethodEntryStatement(node));
  delegate.addNode(new MethodExitStatement(node));
}
Program: 100084
Project: 100084
Buggy source:
private ResolutionFailure(CGNode node,Object ref){
  this(node,ref,null);
}

Fixed version (ground truth):
private ResolutionFailure(CGNode node,T ref){
  this(node,ref,null);
}
Program: 100085
Project: 100085
Buggy source:
@Override public int hashCode(){
  return getMethod().hashCode() * 8999 + ref.hashCode() * 8461 + getLevel();
}

Fixed version (ground truth):
@Override public int hashCode(){
  final int prime=31;
  int result=super.hashCode();
  result=prime * result + ((message == null) ? 0 : message.hashCode());
  result=prime * result + ((ref == null) ? 0 : ref.hashCode());
  return result;
}
Program: 100086
Project: 100086
Buggy source:
@Override public boolean equals(Object obj){
  if (obj == null) {
    return false;
  }
  if (getClass().equals(obj.getClass())) {
    ResolutionFailure other=(ResolutionFailure)obj;
    return (getMethod().equals(other.getMethod()) && getLevel() == other.getLevel() && ref.equals(other.ref));
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj)   return true;
  if (!super.equals(obj))   return false;
  if (getClass() != obj.getClass())   return false;
  final ResolutionFailure other=(ResolutionFailure)obj;
  if (message == null) {
    if (other.message != null)     return false;
  }
 else   if (!message.equals(other.message))   return false;
  if (ref == null) {
    if (other.ref != null)     return false;
  }
 else   if (!ref.equals(other.ref))   return false;
  return true;
}
Program: 100087
Project: 100087
Buggy source:
public static ResolutionFailure create(CGNode node,Object ref,String msg) throws IllegalArgumentException {
  if (node == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return new ResolutionFailure(node,ref,msg);
}

Fixed version (ground truth):
public static <T>ResolutionFailure create(CGNode node,T ref){
  if (node == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return new ResolutionFailure<T>(node,ref);
}
Program: 100088
Project: 100088
Buggy source:
@Override public int hashCode(){
  return method.hashCode();
}

Fixed version (ground truth):
@Override public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime * result + ((declaringClass == null) ? 0 : declaringClass.hashCode());
  result=prime * result + ((method == null) ? 0 : method.hashCode());
  return result;
}
Program: 100089
Project: 100089
Buggy source:
@Override public boolean equals(Object obj){
  if (obj == null) {
    return false;
  }
  if (getClass().equals(obj.getClass())) {
    SyntheticMethod other=(SyntheticMethod)obj;
    return (method.equals(other.method));
  }
 else {
    return false;
  }
}

Fixed version (ground truth):
@Override public boolean equals(Object obj){
  if (this == obj)   return true;
  if (obj == null)   return false;
  if (getClass() != obj.getClass())   return false;
  final SyntheticMethod other=(SyntheticMethod)obj;
  if (declaringClass == null) {
    if (other.declaringClass != null)     return false;
  }
 else   if (!declaringClass.equals(other.declaringClass))   return false;
  if (method == null) {
    if (other.method != null)     return false;
  }
 else   if (!method.equals(other.method))   return false;
  return true;
}
Program: 100090
Project: 100090
Buggy source:
private SSAInstruction[] makeStatements(JavaTypeContext context){
  ArrayList<SSAInstruction> statements=new ArrayList<SSAInstruction>();
  int nextLocal=1;
  int retValue=nextLocal++;
  TypeReference tr=context.getType().getTypeReference();
  if (tr != null) {
    SSALoadClassInstruction l=new SSALoadClassInstruction(retValue,tr);
    statements.add(l);
    SSAReturnInstruction R=new SSAReturnInstruction(retValue,false);
    statements.add(R);
  }
 else {
    SSAThrowInstruction t=new SSAThrowInstruction(retValue);
    statements.add(t);
  }
  SSAInstruction[] result=new SSAInstruction[statements.size()];
  Iterator<SSAInstruction> it=statements.iterator();
  for (int i=0; i < result.length; i++) {
    result[i]=it.next();
  }
  return result;
}

Fixed version (ground truth):
private SSAInstruction[] makeStatements(JavaTypeContext context){
  ArrayList<SSAInstruction> statements=new ArrayList<SSAInstruction>();
  int retValue=2;
  TypeReference tr=context.getType().getTypeReference();
  if (tr != null) {
    SSALoadClassInstruction l=new SSALoadClassInstruction(retValue,tr);
    statements.add(l);
    SSAReturnInstruction R=new SSAReturnInstruction(retValue,false);
    statements.add(R);
  }
 else {
    SSAThrowInstruction t=new SSAThrowInstruction(retValue);
    statements.add(t);
  }
  SSAInstruction[] result=new SSAInstruction[statements.size()];
  statements.toArray(result);
  return result;
}
Program: 100091
Project: 100091
Buggy source:
@Override public TypeAbstraction meet(TypeAbstraction rhs){
  if (rhs == TOP) {
    return this;
  }
 else {
    if (rhs instanceof PointType) {
      PointType other=(PointType)rhs;
      if (type.equals(other.type)) {
        return this;
      }
 else       if (type.isArrayClass() || other.type.isArrayClass()) {
        return new ConeType(type.getClassHierarchy().getRootClass());
      }
 else {
        return new ConeType(type.getClassHierarchy().getLeastCommonSuperclass(this.type,other.type));
      }
    }
 else     if (rhs instanceof ConeType) {
      ConeType other=(ConeType)rhs;
      TypeReference T=other.getType().getReference();
      if (type.isArrayClass() || T.isArrayType()) {
        return new ConeType(type.getClassHierarchy().getRootClass());
      }
      IClass typeKlass=type;
      if (type.getClassHierarchy().isSubclassOf(typeKlass,other.getType())) {
        return other;
      }
 else       if (other.isInterface()) {
        if (type.getClassHierarchy().implementsInterface(typeKlass,other.getType())) {
          return other;
        }
      }
      return other.meet(new ConeType(other.getType()));
    }
 else {
      Assertions.UNREACHABLE("String_Node_Str" + rhs.getClass());
      return null;
    }
  }
}

Fixed version (ground truth):
@Override public TypeAbstraction meet(TypeAbstraction rhs){
  if (rhs == TOP) {
    return this;
  }
 else {
    if (rhs instanceof PointType) {
      PointType other=(PointType)rhs;
      if (type.equals(other.type)) {
        return this;
      }
 else       if (type.isArrayClass() || other.type.isArrayClass()) {
        return new ConeType(type.getClassHierarchy().getRootClass());
      }
 else {
        return new ConeType(type.getClassHierarchy().getLeastCommonSuperclass(this.type,other.type));
      }
    }
 else     if (rhs instanceof ConeType) {
      ConeType other=(ConeType)rhs;
      TypeReference T=other.getType().getReference();
      if (type.isArrayClass() || T.isArrayType()) {
        return new ConeType(type.getClassHierarchy().getRootClass());
      }
      IClass typeKlass=type;
      if (type.getClassHierarchy().isSubclassOf(typeKlass,other.getType())) {
        return other;
      }
 else       if (other.isInterface()) {
        if (type.getClassHierarchy().implementsInterface(typeKlass,other.getType())) {
          return other;
        }
      }
      return other.meet(new ConeType(this.getType()));
    }
 else {
      Assertions.UNREACHABLE("String_Node_Str" + rhs.getClass());
      return null;
    }
  }
}
Program: 100092
Project: 100092
Buggy source:
/** 
 * Does c implement i?
 * @return true iff i is an interface and c is a class that implements i, r cis an interface that extends i.
 */
public boolean implementsInterface(IClass c,IClass i){
  if (!i.isInterface()) {
    return false;
  }
  Set impls=implementors.get(i);
  if (impls != null && impls.contains(c)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
/** 
 * Does c implement i?
 * @return true iff i is an interface and c is a class that implements i, r c is an interface that extends i.
 */
public boolean implementsInterface(IClass c,IClass i){
  if (!i.isInterface()) {
    return false;
  }
  if (c.equals(i)) {
    return true;
  }
  Set impls=implementors.get(i);
  if (impls != null && impls.contains(c)) {
    return true;
  }
  return false;
}
Program: 100093
Project: 100093
Buggy source:
/** 
 * Get the targets for a method ref invoked on a class klass. The klass had better not be an interface.
 * @param ref method to invoke
 * @param klass declaringClass of receiver
 * @return Set the set of method implementations that might receive themessage
 */
private Set<IMethod> computeTargetsNotInterface(MethodReference ref,IClass klass){
  Node n=findNode(klass);
  HashSet<IMethod> result=HashSetFactory.make(3);
  if (n == null)   return result;
  Selector selector=ref.getSelector();
  IMethod resolved=resolveMethod(klass,selector);
  if (resolved != null) {
    result.add(resolved);
  }
  result.addAll(computeOverriders(n,selector));
  return result;
}

Fixed version (ground truth):
/** 
 * Get the targets for a method ref invoked on a class klass. The klass had better not be an interface.
 * @param ref method to invoke
 * @param klass declaringClass of receiver
 * @return Set the set of method implementations that might receive the message
 */
private Set<IMethod> computeTargetsNotInterface(MethodReference ref,IClass klass){
  Node n=findNode(klass);
  HashSet<IMethod> result=HashSetFactory.make(3);
  if (n == null)   return result;
  Selector selector=ref.getSelector();
  IMethod resolved=resolveMethod(klass,selector);
  if (resolved != null) {
    result.add(resolved);
  }
  result.addAll(computeOverriders(n,selector));
  return result;
}
Program: 100095
Project: 100095
Buggy source:
/** 
 * @return the canonical IField that represents a given field , or null ifnone found
 * @throws IllegalArgumentException if f is null
 * @throws IllegalArgumentException if klass is null
 */
public IField resolveField(IClass klass,FieldReference f){
  if (klass == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (f == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return klass.getField(f.getName());
}

Fixed version (ground truth):
/** 
 * @return the canonical IField that represents a given field , or null if none found
 * @throws IllegalArgumentException if f is null
 * @throws IllegalArgumentException if klass is null
 */
public IField resolveField(IClass klass,FieldReference f){
  if (klass == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (f == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return klass.getField(f.getName());
}
Program: 100097
Project: 100097
Buggy source:
/** 
 * Compute the set of   {@link InstanceKey}s which may represent a particular type.
 */
private OrdinalSet<InstanceKey> computeOrdinalInstanceSet(IClass type){
  Collection<IClass> klasses=null;
  if (type.isInterface()) {
    klasses=getCallGraph().getClassHierarchy().getImplementors(type.getReference());
  }
 else {
    Collection<IClass> sc=getCallGraph().getClassHierarchy().computeSubClasses(type.getReference());
    klasses=HashSetFactory.make();
    for (    IClass c : sc) {
      if (!c.isInterface()) {
        klasses.add(c);
      }
    }
  }
  Collection<IClass> c=HashSetFactory.make();
  for (  IClass klass : klasses) {
    if (klass.isArrayClass()) {
      c.add(klass);
    }
 else     if (this.klasses.contains(klass)) {
      c.add(klass);
    }
  }
  OrdinalSet<InstanceKey> result=toOrdinalInstanceKeySet(c);
  return result;
}

Fixed version (ground truth):
/** 
 * Compute the set of   {@link InstanceKey}s which may represent a particular type.
 */
private OrdinalSet<InstanceKey> computeOrdinalInstanceSet(IClass type){
  Collection<IClass> klasses=null;
  if (type.isInterface()) {
    klasses=getCallGraph().getClassHierarchy().getImplementors(type.getReference());
  }
 else {
    Collection<IClass> sc=getCallGraph().getClassHierarchy().computeSubClasses(type.getReference());
    klasses=HashSetFactory.make();
    for (    IClass c : sc) {
      if (!c.isInterface()) {
        klasses.add(c);
      }
    }
  }
  Collection<IClass> c=HashSetFactory.make();
  for (  IClass klass : klasses) {
    if (klass.isArrayClass()) {
      TypeReference elementType=klass.getReference().getArrayElementType();
      if (elementType.isPrimitiveType()) {
        c.add(klass);
      }
 else {
        c.add(klass.getClassHierarchy().lookupClass(TypeReference.JavaLangObject.getArrayTypeForElementType()));
      }
    }
 else     if (this.klasses.contains(klass)) {
      c.add(klass);
    }
  }
  OrdinalSet<InstanceKey> result=toOrdinalInstanceKeySet(c);
  return result;
}
Program: 100098
Project: 100098
Buggy source:
/** 
 * Add any methods that look like they might be DispatchAction targets, based on the method signature. TODO: instead, parse the struts xml directly.
 * @param klass an Action
 */
private void addSpeculativeDispatchMethods(IClass klass,IClassHierarchy cha){
  IClass C=klass;
  while (C != null) {
    for (Iterator<IMethod> it=C.getDeclaredMethods().iterator(); it.hasNext(); ) {
      IMethod M=(IMethod)it.next();
      Descriptor D=M.getDescriptor();
      if (D.equals(executeDesc) || D.equals(httpExecuteDesc)) {
        MethodReference m=MethodReference.findOrCreate(klass.getReference(),M.getName(),M.getDescriptor());
        entrypoints.put(m,new StrutsActionEntrypoint(C,M,cha));
      }
    }
    try {
      C=C.getSuperclass();
    }
 catch (    ClassHierarchyException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}

Fixed version (ground truth):
/** 
 * Add any methods that look like they might be DispatchAction targets, based on the method signature. TODO: instead, parse the struts xml directly.
 * @param klass an Action
 */
private void addSpeculativeDispatchMethods(IClass klass,IClassHierarchy cha){
  IClass c=klass;
  while (c != null) {
    for (Iterator<IMethod> it=c.getDeclaredMethods().iterator(); it.hasNext(); ) {
      IMethod M=(IMethod)it.next();
      Descriptor D=M.getDescriptor();
      if (D.equals(executeDesc) || D.equals(httpExecuteDesc)) {
        MethodReference m=MethodReference.findOrCreate(klass.getReference(),M.getName(),M.getDescriptor());
        entrypoints.put(m,new StrutsActionEntrypoint(klass,M,cha));
      }
    }
    try {
      c=c.getSuperclass();
    }
 catch (    ClassHierarchyException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}
Program: 100099
Project: 100099
Buggy source:
public static boolean isConcreteStrutsPlugIn(IClass klass){
  TypeReference plugInType=TypeReference.findOrCreate(ClassLoaderReference.Application,plugInName);
  IClass plugInClass=klass.getClassHierarchy().lookupClass(plugInType);
  if (klass.isAbstract()) {
    return false;
  }
  if (klass.getReference().equals(plugInType)) {
    return false;
  }
  if (klass.getClassHierarchy().isAssignableFrom(plugInClass,klass)) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
public static boolean isConcreteStrutsPlugIn(IClass klass){
  TypeReference plugInType=TypeReference.findOrCreate(ClassLoaderReference.Application,plugInName);
  IClass plugInClass=klass.getClassHierarchy().lookupClass(plugInType);
  if (plugInClass == null) {
    return false;
  }
  if (klass.isAbstract()) {
    return false;
  }
  if (klass.getReference().equals(plugInType)) {
    return false;
  }
  if (klass.getClassHierarchy().isAssignableFrom(plugInClass,klass)) {
    return true;
  }
  return false;
}
Program: 100100
Project: 100100
Buggy source:
protected CGNode makeFakeRootNode(){
  return findOrCreateNode(new JSFakeRoot(cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}

Fixed version (ground truth):
protected CGNode makeFakeRootNode() throws CancelException {
  return findOrCreateNode(new JSFakeRoot(cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}
Program: 100101
Project: 100101
Buggy source:
protected CGNode makeFakeRootNode(){
  return findOrCreateNode(new AstFakeRoot(FakeRootMethod.rootMethod,cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}

Fixed version (ground truth):
protected CGNode makeFakeRootNode() throws CancelException {
  return findOrCreateNode(new AstFakeRoot(FakeRootMethod.rootMethod,cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}
Program: 100102
Project: 100102
Buggy source:
protected CGNode makeFakeRootNode(){
  return findOrCreateNode(new CrossLanguageFakeRoot(cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}

Fixed version (ground truth):
protected CGNode makeFakeRootNode() throws CancelException {
  return findOrCreateNode(new CrossLanguageFakeRoot(cha,options,getAnalysisCache()),Everywhere.EVERYWHERE);
}