nus-yam/ex-repair huggingface dataset:
Program: 60587
Project: 60587
Buggy source:
/** 
 * Fails unless   {@code expected.equals(actual)},   {@code actual.equals(expected)} and their hash codes are equal. This is usefulfor testing the equals method itself.
 */
public static void assertEqualsBothWays(Object expected,Object actual){
  Assert.assertNotNull(expected);
  Assert.assertNotNull(actual);
  Assert.assertTrue("String_Node_Str",expected.equals(actual));
  Assert.assertTrue("String_Node_Str",actual.equals(expected));
  Assert.assertEquals("String_Node_Str",expected.hashCode(),actual.hashCode());
}

Fixed version (ground truth):
/** 
 * Fails unless   {@code expected.equals(actual)},   {@code actual.equals(expected)} and their hash codes are equal. This is usefulfor testing the equals method itself.
 */
public static void assertEqualsBothWays(Object expected,Object actual){
  assertNotNull(expected);
  assertNotNull(actual);
  assertTrue("String_Node_Str",expected.equals(actual));
  assertTrue("String_Node_Str",actual.equals(expected));
  assertEquals("String_Node_Str",expected.hashCode(),actual.hashCode());
}
Program: 60588
Project: 60588
Buggy source:
/** 
 * Fails unless   {@code text} includes all {@code substrings}, in order.
 */
public static void assertContains(String text,String... substrings){
  int startingFrom=0;
  for (int i=0; i < substrings.length; i++) {
    int index=text.indexOf(substrings[i],startingFrom);
    Assert.assertTrue(String.format("String_Node_Str",text,substrings[i]),index >= startingFrom);
    startingFrom=index + substrings[i].length();
  }
  String lastSubstring=substrings[substrings.length - 1];
  Assert.assertTrue(String.format("String_Node_Str",text,lastSubstring),text.indexOf(lastSubstring,startingFrom) == -1);
}

Fixed version (ground truth):
/** 
 * Fails unless   {@code text} includes all {@code substrings}, in order.
 */
public static void assertContains(String text,String... substrings){
  int startingFrom=0;
  for (  String substring : substrings) {
    int index=text.indexOf(substring,startingFrom);
    assertTrue(String.format("String_Node_Str",text,substring),index >= startingFrom);
    startingFrom=index + substring.length();
  }
  String lastSubstring=substrings[substrings.length - 1];
  assertTrue(String.format("String_Node_Str",text,lastSubstring),text.indexOf(lastSubstring,startingFrom) == -1);
}
Program: 60589
Project: 60589
Buggy source:
static Object reserialize(Object object) throws IOException {
  try {
    ByteArrayOutputStream out=new ByteArrayOutputStream();
    new ObjectOutputStream(out).writeObject(object);
    ByteArrayInputStream in=new ByteArrayInputStream(out.toByteArray());
    return new ObjectInputStream(in).readObject();
  }
 catch (  ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}

Fixed version (ground truth):
public static <E>E reserialize(E original) throws IOException {
  try {
    ByteArrayOutputStream out=new ByteArrayOutputStream();
    new ObjectOutputStream(out).writeObject(original);
    ByteArrayInputStream in=new ByteArrayInputStream(out.toByteArray());
    @SuppressWarnings("String_Node_Str") E reserialized=(E)new ObjectInputStream(in).readObject();
    return reserialized;
  }
 catch (  ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
}
Program: 60590
Project: 60590
Buggy source:
public void testSerialization() throws IOException, NoSuchFieldException {
  assertEqualWhenReserialized(Key.get(B.class));
  assertEqualWhenReserialized(Key.get(B.class,Names.named("String_Node_Str")));
  assertEqualWhenReserialized(Key.get(B.class,Named.class));
  assertEqualWhenReserialized(Key.get(B[].class));
  assertEqualWhenReserialized(Key.get(new TypeLiteral<Map<List<B>,B>>(){
  }
));
  assertEqualWhenReserialized(Key.get(new TypeLiteral<List<B[]>>(){
  }
));
  assertEqualWhenReserialized(new Key<List<B[]>>(){
  }
);
  assertEqualWhenReserialized(Key.get(Types.listOf(Types.subtypeOf(CharSequence.class))));
}

Fixed version (ground truth):
public void testSerialization() throws IOException, NoSuchFieldException {
  assertEqualWhenReserialized(Key.get(B.class));
  assertEqualWhenReserialized(Key.get(B.class,Names.named("String_Node_Str")));
  assertEqualWhenReserialized(Key.get(B.class,Named.class));
  assertEqualWhenReserialized(Key.get(B[].class));
  assertEqualWhenReserialized(Key.get(new TypeLiteral<Map<List<B>,B>>(){
  }
));
  assertEqualWhenReserialized(Key.get(new TypeLiteral<List<B[]>>(){
  }
));
  assertEquals(new Key<List<B[]>>(){
  }
,Asserts.reserialize(new Key<List<B[]>>(){
  }
));
  assertEqualWhenReserialized(Key.get(Types.listOf(Types.subtypeOf(CharSequence.class))));
}
Program: 60591
Project: 60591
Buggy source:
public void testWithWildcardType() throws NoSuchFieldException, IOException {
  TypeLiteral<?> a=TypeLiteral.get(getClass().getField("String_Node_Str").getGenericType());
  TypeLiteral<?> b=TypeLiteral.get(Types.listOf(Types.subtypeOf(CharSequence.class)));
  assertEqualsBothWays(a,b);
  assertEquals("String_Node_Str",a.toString());
  assertEquals("String_Node_Str",b.toString());
  assertEqualWhenReserialized(a);
  assertEqualWhenReserialized(b);
}

Fixed version (ground truth):
public void testWithWildcardType() throws NoSuchFieldException, IOException {
  TypeLiteral<?> a=TypeLiteral.get(getClass().getField("String_Node_Str").getGenericType());
  TypeLiteral<?> b=TypeLiteral.get(Types.listOf(Types.subtypeOf(CharSequence.class)));
  assertEqualsBothWays(a,b);
  assertEquals("String_Node_Str",a.toString());
  assertEquals("String_Node_Str",b.toString());
  assertNotSerializable(a);
  assertNotSerializable(b);
}
Program: 60592
Project: 60592
Buggy source:
public void testSerialization() throws IOException {
  assertEqualWhenReserialized(new TypeLiteral<List<String>>(){
  }
);
}

Fixed version (ground truth):
public void testSerialization() throws IOException {
  assertNotSerializable(new TypeLiteral<List<String>>(){
  }
);
}
Program: 60593
Project: 60593
Buggy source:
BindCommandProcessor(Errors errors,InjectorImpl injector,Map<Class<? extends Annotation>,Scope> scopes,Map<Key<?>,BindingImpl<?>> bindings,Set<Object> outstandingInjections){
  super(errors);
  this.injector=injector;
  this.scopes=scopes;
  this.bindings=bindings;
  this.outstandingInjections=outstandingInjections;
}

Fixed version (ground truth):
BindCommandProcessor(Errors errors,InjectorImpl injector,Map<Class<? extends Annotation>,Scope> scopes,Map<Key<?>,BindingImpl<?>> bindings,CreationTimeMemberInjector memberInjector){
  super(errors);
  this.injector=injector;
  this.scopes=scopes;
  this.bindings=bindings;
  this.memberInjector=memberInjector;
}
Program: 60595
Project: 60595
Buggy source:
public Void visitToProvider(Provider<? extends T> provider){
  InternalFactoryToProviderAdapter<? extends T> factory=new InternalFactoryToProviderAdapter<T>(provider,source);
  outstandingInjections.add(provider);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  putBinding(new ProviderInstanceBindingImpl<T>(injector,key,source,scopedFactory,scope,provider,loadStrategy));
  return null;
}

Fixed version (ground truth):
public Void visitToProvider(Provider<? extends T> provider){
  InternalFactoryToProviderAdapter<? extends T> factory=new InternalFactoryToProviderAdapter<T>(provider,source);
  memberInjector.add(provider);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  putBinding(new ProviderInstanceBindingImpl<T>(injector,key,source,scopedFactory,scope,provider,loadStrategy));
  return null;
}
Program: 60596
Project: 60596
Buggy source:
public Void visitToInstance(T instance){
  if (instance == null) {
    errors.cannotBindToNullInstance();
    putBinding(invalidBinding(injector,key,source));
    return null;
  }
  ConstantFactory<? extends T> factory=new ConstantFactory<T>(instance);
  outstandingInjections.add(instance);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  putBinding(new InstanceBindingImpl<T>(injector,key,source,scopedFactory,instance));
  return null;
}

Fixed version (ground truth):
public Void visitToInstance(T instance){
  if (instance == null) {
    errors.cannotBindToNullInstance();
    putBinding(invalidBinding(injector,key,source));
    return null;
  }
  ConstantFactory<? extends T> factory=new ConstantFactory<T>(instance);
  memberInjector.add(instance);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  putBinding(new InstanceBindingImpl<T>(injector,key,source,scopedFactory,instance));
  return null;
}
Program: 60597
Project: 60597
Buggy source:
/** 
 * Builds the injector. 
 */
private void buildCoreInjector(){
  new ErrorsCommandProcessor(errors).processCommands(commands);
  BindInterceptorCommandProcessor bindInterceptorCommandProcessor=new BindInterceptorCommandProcessor(errors);
  bindInterceptorCommandProcessor.processCommands(commands);
  ConstructionProxyFactory proxyFactory=bindInterceptorCommandProcessor.createProxyFactory();
  injector.reflection=reflectionFactory.create(proxyFactory);
  stopwatch.resetAndLog("String_Node_Str");
  new ScopesCommandProcessor(errors,injector.scopes).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  new ConvertToTypesCommandProcessor(errors,injector.converters).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  bindLogger();
  bindCommandProcesor=new BindCommandProcessor(errors,injector,injector.scopes,injector.explicitBindings,injector.outstandingInjections);
  bindCommandProcesor.processCommands(commands);
  bindCommandProcesor.createUntargettedBindings();
  stopwatch.resetAndLog("String_Node_Str");
  injector.index();
  stopwatch.resetAndLog("String_Node_Str");
  requestInjectionCommandProcessor=new RequestInjectionCommandProcessor(errors,injector.outstandingInjections);
  requestInjectionCommandProcessor.processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Builds the injector. 
 */
private void buildCoreInjector(){
  new ErrorsCommandProcessor(errors).processCommands(commands);
  BindInterceptorCommandProcessor bindInterceptorCommandProcessor=new BindInterceptorCommandProcessor(errors);
  bindInterceptorCommandProcessor.processCommands(commands);
  ConstructionProxyFactory proxyFactory=bindInterceptorCommandProcessor.createProxyFactory();
  injector.reflection=reflectionFactory.create(proxyFactory);
  stopwatch.resetAndLog("String_Node_Str");
  new ScopesCommandProcessor(errors,injector.scopes).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  new ConvertToTypesCommandProcessor(errors,injector.converters).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  bindLogger();
  bindCommandProcesor=new BindCommandProcessor(errors,injector,injector.scopes,injector.explicitBindings,injector.memberInjector);
  bindCommandProcesor.processCommands(commands);
  bindCommandProcesor.createUntargettedBindings();
  stopwatch.resetAndLog("String_Node_Str");
  injector.index();
  stopwatch.resetAndLog("String_Node_Str");
  requestInjectionCommandProcessor=new RequestInjectionCommandProcessor(errors,injector.memberInjector);
  requestInjectionCommandProcessor.processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
}
Program: 60598
Project: 60598
Buggy source:
/** 
 * Inject everything that can be injected. 
 */
private void fulfillInjectionRequests(){
  requestInjectionCommandProcessor.injectMembers(injector);
  stopwatch.resetAndLog("String_Node_Str");
  injector.fulfillOutstandingInjections(errors);
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
  loadEagerSingletons();
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
}

Fixed version (ground truth):
/** 
 * Inject everything that can be injected. 
 */
private void fulfillInjectionRequests(){
  requestInjectionCommandProcessor.injectMembers(injector);
  stopwatch.resetAndLog("String_Node_Str");
  injector.memberInjector.injectAll(errors);
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
  loadEagerSingletons();
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
}
Program: 60599
Project: 60599
Buggy source:
/** 
 * Validate everything that we can validate now that the injector is ready for use. 
 */
private void validate(){
  bindCommandProcesor.runCreationListeners(injector);
  stopwatch.resetAndLog("String_Node_Str");
  requestInjectionCommandProcessor.validate(injector);
  stopwatch.resetAndLog("String_Node_Str");
  injector.validateOustandingInjections(errors);
  stopwatch.resetAndLog("String_Node_Str");
  new GetProviderProcessor(errors,injector).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
}

Fixed version (ground truth):
/** 
 * Validate everything that we can validate now that the injector is ready for use. 
 */
private void validate(){
  bindCommandProcesor.runCreationListeners(injector);
  stopwatch.resetAndLog("String_Node_Str");
  requestInjectionCommandProcessor.validate(injector);
  stopwatch.resetAndLog("String_Node_Str");
  injector.memberInjector.validateOustandingInjections(errors);
  stopwatch.resetAndLog("String_Node_Str");
  new GetProviderProcessor(errors,injector).processCommands(commands);
  stopwatch.resetAndLog("String_Node_Str");
  errors.throwCreationExceptionIfErrorsExist();
}
Program: 60600
Project: 60600
Buggy source:
/** 
 * Ensures that an object requiring injection at Injector-creation time has been injected before its use.
 */
public void ensureMemberInjected(Errors errors,Object toInject) throws ErrorsException {
  if (!injector.outstandingInjections.remove(toInject)) {
    return;
  }
  injector.injectMembersOrThrow(errors,toInject);
}

Fixed version (ground truth):
/** 
 * Ensures that an object requiring injection at Injector-creation time has been injected before its use.
 */
public void ensureMemberInjected(Errors errors,Object toInject) throws ErrorsException {
  injector.memberInjector.ensureInjected(errors,toInject);
}
Program: 60601
Project: 60601
Buggy source:
@Override public Boolean visitRequestInjection(RequestInjectionCommand command){
  for (  Object instance : command.getInstances()) {
    outstandingInjections.add(instance);
  }
  return true;
}

Fixed version (ground truth):
@Override public Boolean visitRequestInjection(RequestInjectionCommand command){
  for (  Object instance : command.getInstances()) {
    memberInjector.add(instance);
  }
  return true;
}
Program: 60602
Project: 60602
Buggy source:
RequestInjectionCommandProcessor(Errors errors,Set<Object> outstandingInjections){
  super(errors);
  this.outstandingInjections=outstandingInjections;
}

Fixed version (ground truth):
RequestInjectionCommandProcessor(Errors errors,CreationTimeMemberInjector memberInjector){
  super(errors);
  this.memberInjector=memberInjector;
}
Program: 60603
Project: 60603
Buggy source:
public void testBindingOrderAndScopes(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(A.class);
      bind(B.class).asEagerSingleton();
    }
  }
);
  assertSame("String_Node_Str",injector.getInstance(A.class).b,injector.getInstance(A.class).b);
}

Fixed version (ground truth):
public void testBindingOrderAndScopes(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(A.class);
      bind(B.class).asEagerSingleton();
    }
  }
);
  assertSame(injector.getInstance(A.class).b,injector.getInstance(A.class).b);
}
Program: 60604
Project: 60604
Buggy source:
protected void configure(){
  bind(A.class);
  bind(B.class).asEagerSingleton();
}

Fixed version (ground truth):
protected void configure(){
  requestInjection(createsAThread);
  bind(A.class).toInstance(new A());
}
Program: 60605
Project: 60605
Buggy source:
public void testRelatedTypeVariables(){
  TypeResolver resolver=new TypeResolver(arrayListOfString);
  assertEquals(String.class,resolver.getParameterTypes(echo).get(0));
  assertEquals(String.class,resolver.getReturnType(echo));
}

Fixed version (ground truth):
public void testRelatedTypeVariables(){
  TypeResolver resolver=new TypeResolver(hasRelatedOfString);
  assertEquals(String.class,resolver.getParameterTypes(echo).get(0));
  assertEquals(String.class,resolver.getReturnType(echo));
}
Program: 60606
Project: 60606
Buggy source:
public void run(){
  for (  Map.Entry<Object,Object> entry : properties.entrySet()) {
    String key=(String)entry.getKey();
    String value=(String)entry.getValue();
    binder.bind(Key.get(String.class,new NamedImpl(key))).toInstance(value);
  }
}

Fixed version (ground truth):
public void run(){
  for (Enumeration<?> e=properties.propertyNames(); e.hasMoreElements(); ) {
    String propertyName=(String)e.nextElement();
    String value=properties.getProperty(propertyName);
    binder.bind(Key.get(String.class,new NamedImpl(propertyName))).toInstance(value);
  }
}
Program: 60607
Project: 60607
Buggy source:
/** 
 * Creates a constant binding to   {@code @Named(key)} for each property.
 */
public static void bindProperties(final Binder binder,final Properties properties){
  SourceProviders.withDefault(SourceProviders.defaultSource(),new Runnable(){
    public void run(){
      for (      Map.Entry<Object,Object> entry : properties.entrySet()) {
        String key=(String)entry.getKey();
        String value=(String)entry.getValue();
        binder.bind(Key.get(String.class,new NamedImpl(key))).toInstance(value);
      }
    }
  }
);
}

Fixed version (ground truth):
/** 
 * Creates a constant binding to   {@code @Named(key)} for each property. Thismethod binds all properties including those inherited from  {@link Properties#defaults defaults}.
 */
public static void bindProperties(final Binder binder,final Properties properties){
  SourceProviders.withDefault(SourceProviders.defaultSource(),new Runnable(){
    public void run(){
      for (Enumeration<?> e=properties.propertyNames(); e.hasMoreElements(); ) {
        String propertyName=(String)e.nextElement();
        String value=properties.getProperty(propertyName);
        binder.bind(Key.get(String.class,new NamedImpl(propertyName))).toInstance(value);
      }
    }
  }
);
}
Program: 60608
Project: 60608
Buggy source:
/** 
 * Creates a construction proxy given a class and parameter types.
 */
private <T>ConstructionProxy<T> createConstructionProxy(final Class<?> clazz,final Constructor standardConstructor){
  FastClass fastClass=GuiceFastClass.create(clazz);
  final FastConstructor fastConstructor=fastClass.getConstructor(standardConstructor.getParameterTypes());
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,fastConstructor.getJavaConstructor());
    }
    public Member getMember(){
      return standardConstructor;
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Creates a construction proxy given a class and parameter types.
 */
private <T>ConstructionProxy<T> createConstructionProxy(final Class<?> clazz,final Constructor standardConstructor){
  FastClass fastClass=GuiceFastClass.create(clazz);
  final FastConstructor fastConstructor=fastClass.getConstructor(standardConstructor.getParameterTypes());
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,standardConstructor);
    }
    public Member getMember(){
      return standardConstructor;
    }
  }
;
}
Program: 60609
Project: 60609
Buggy source:
public List<Parameter<?>> getParameters(){
  return Parameter.forConstructor(errorHandler,fastConstructor.getJavaConstructor());
}

Fixed version (ground truth):
public List<Parameter<?>> getParameters(){
  return Parameter.forConstructor(errorHandler,standardConstructor);
}
Program: 60610
Project: 60610
Buggy source:
public <T>ConstructionProxy<T> get(final Constructor<T> constructor){
  if (Modifier.isPrivate(constructor.getModifiers()) || Modifier.isProtected(constructor.getModifiers())) {
    constructor.setAccessible(true);
    return new ConstructionProxy<T>(){
      public T newInstance(      Object... arguments) throws InvocationTargetException {
        try {
          return constructor.newInstance(arguments);
        }
 catch (        InstantiationException e) {
          throw new RuntimeException(e);
        }
catch (        IllegalAccessException e) {
          throw new AssertionError(e);
        }
      }
      public List<Parameter<?>> getParameters(){
        return Parameter.forConstructor(errorHandler,constructor);
      }
      public Member getMember(){
        return constructor;
      }
    }
;
  }
  Class<T> classToConstruct=constructor.getDeclaringClass();
  FastClass fastClass=GuiceFastClass.create(classToConstruct);
  final FastConstructor fastConstructor=fastClass.getConstructor(constructor);
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,fastConstructor);
    }
    public Member getMember(){
      return fastConstructor.getJavaConstructor();
    }
  }
;
}

Fixed version (ground truth):
public <T>ConstructionProxy<T> get(final Constructor<T> constructor){
  if (Modifier.isPrivate(constructor.getModifiers()) || Modifier.isProtected(constructor.getModifiers())) {
    constructor.setAccessible(true);
    return new ConstructionProxy<T>(){
      public T newInstance(      Object... arguments) throws InvocationTargetException {
        try {
          return constructor.newInstance(arguments);
        }
 catch (        InstantiationException e) {
          throw new RuntimeException(e);
        }
catch (        IllegalAccessException e) {
          throw new AssertionError(e);
        }
      }
      public List<Parameter<?>> getParameters(){
        return Parameter.forConstructor(errorHandler,constructor);
      }
      public Member getMember(){
        return constructor;
      }
    }
;
  }
  Class<T> classToConstruct=constructor.getDeclaringClass();
  FastClass fastClass=GuiceFastClass.create(classToConstruct);
  final FastConstructor fastConstructor=fastClass.getConstructor(constructor);
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,constructor);
    }
    public Member getMember(){
      return constructor;
    }
  }
;
}
Program: 60611
Project: 60611
Buggy source:
public List<Parameter<?>> getParameters(){
  return Parameter.forConstructor(errorHandler,fastConstructor);
}

Fixed version (ground truth):
public List<Parameter<?>> getParameters(){
  return Parameter.forConstructor(errorHandler,constructor);
}
Program: 60612
Project: 60612
Buggy source:
public Member getMember(){
  return fastConstructor.getJavaConstructor();
}

Fixed version (ground truth):
public Member getMember(){
  return constructor;
}
Program: 60613
Project: 60613
Buggy source:
public Void visitUntargetted(){
  final Type type=key.getTypeLiteral().getType();
  if (key.hasAnnotationType() || !(type instanceof Class<?>)) {
    addError(source,ErrorMessages.MISSING_IMPLEMENTATION);
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  untargettedBindings.add(new Runnable(){
    public void run(){
      @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
      try {
        BindingImpl<T> binding=injector.createBindingFromType(clazz,scope,source);
        createBinding(source,shouldPreload,binding);
      }
 catch (      ResolveFailedException e) {
        injector.errorHandler.handle(source,e.getMessage());
        createBinding(source,shouldPreload,invalidBinding(injector,key,source));
      }
    }
  }
);
  return null;
}

Fixed version (ground truth):
public Void visitUntargetted(){
  final Type type=key.getTypeLiteral().getType();
  if (key.hasAnnotationType() || !(type instanceof Class<?>)) {
    addError(source,ErrorMessages.MISSING_IMPLEMENTATION);
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
  final BindingImpl<T> binding;
  try {
    binding=injector.createUnitializedBinding(clazz,scope,source);
    createBinding(source,shouldPreload,binding);
  }
 catch (  ResolveFailedException e) {
    injector.errorHandler.handle(source,e.getMessage());
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  untargettedBindings.add(new Runnable(){
    public void run(){
      try {
        injector.initializeBinding(binding);
      }
 catch (      ResolveFailedException e) {
        injector.errorHandler.handle(source,e.getMessage());
      }
    }
  }
);
  return null;
}
Program: 60615
Project: 60615
Buggy source:
public void run(){
  @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
  try {
    BindingImpl<T> binding=injector.createBindingFromType(clazz,scope,source);
    createBinding(source,shouldPreload,binding);
  }
 catch (  ResolveFailedException e) {
    injector.errorHandler.handle(source,e.getMessage());
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
  }
}

Fixed version (ground truth):
public void run(){
  try {
    injector.initializeBinding(binding);
  }
 catch (  ResolveFailedException e) {
    injector.errorHandler.handle(source,e.getMessage());
  }
}
Program: 60616
Project: 60616
Buggy source:
<T>BindingImpl<T> createBindingFromType(Class<T> type,Scope scope,Object source) throws ResolveFailedException {
  if (type.isArray() || type.isEnum() || type.isPrimitive()) {
    throw new ResolveFailedException(ErrorMessages.MISSING_BINDING,type);
  }
  ImplementedBy implementedBy=type.getAnnotation(ImplementedBy.class);
  if (implementedBy != null) {
    return createImplementedByBinding(type,implementedBy);
  }
  ProvidedBy providedBy=type.getAnnotation(ProvidedBy.class);
  if (providedBy != null) {
    return createProvidedByBinding(type,providedBy);
  }
  return createBindingForInjectableType(type,scope,source);
}

Fixed version (ground truth):
<T>BindingImpl<T> createBindingFromType(Class<T> type,Scope scope,Object source) throws ResolveFailedException {
  BindingImpl<T> binding=createUnitializedBinding(type,scope,source);
  initializeBinding(binding);
  return binding;
}
Program: 60617
Project: 60617
Buggy source:
<T>BindingImpl<T> createBindingJustInTime(Key<T> key){
  if (isProvider(key)) {
    @SuppressWarnings({"String_Node_Str","String_Node_Str"}) BindingImpl<T> binding=(BindingImpl<T>)createProviderBinding((Key)key);
    return binding;
  }
  BindingImpl<T> boxedOrUnboxed=getBoxedOrUnboxedBinding(key);
  if (boxedOrUnboxed != null) {
    return boxedOrUnboxed;
  }
  BindingImpl<T> convertedBinding=convertConstantStringBinding(key);
  if (convertedBinding != null) {
    return convertedBinding;
  }
  if (key.hasAnnotationType()) {
    return key.hasAttributes() ? getBinding(key.withoutAttributes()) : null;
  }
  Type type=key.getTypeLiteral().getType();
  if (!(type instanceof Class)) {
    return null;
  }
  @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
  return createBindingFromType(clazz);
}

Fixed version (ground truth):
<T>BindingImpl<T> createBindingJustInTime(Key<T> key){
  if (isProvider(key)) {
    @SuppressWarnings({"String_Node_Str","String_Node_Str"}) BindingImpl<T> binding=(BindingImpl<T>)createProviderBinding((Key)key);
    return binding;
  }
  BindingImpl<T> boxedOrUnboxed=getBoxedOrUnboxedBinding(key);
  if (boxedOrUnboxed != null) {
    return boxedOrUnboxed;
  }
  BindingImpl<T> convertedBinding=convertConstantStringBinding(key);
  if (convertedBinding != null) {
    return convertedBinding;
  }
  if (key.hasAnnotationType()) {
    return key.hasAttributes() ? getBinding(key.withoutAttributes()) : null;
  }
  @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)key.getTypeLiteral().getRawType();
  return createBindingFromType(clazz);
}
Program: 60618
Project: 60618
Buggy source:
/** 
 * Returns an annotation instance that is not equal to any other annotation instances, for use in creating distinct   {@link Key}s.
 */
private static Annotation uniqueAnnotation(){
  return new Annotation(){
    public Class<? extends Annotation> annotationType(){
      return Internal.class;
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Returns an annotation instance that is not equal to any other annotation instances, for use in creating distinct   {@link Key}s.
 */
private static Annotation uniqueAnnotation(){
  final int value=nextUniqueValue.getAndIncrement();
  return new Internal(){
    public int value(){
      return value;
    }
    public Class<? extends Annotation> annotationType(){
      return Internal.class;
    }
    @Override public String toString(){
      return "String_Node_Str" + Internal.class.getName() + "String_Node_Str"+ value+ "String_Node_Str";
    }
    @Override public boolean equals(    Object o){
      return o instanceof Internal && ((Internal)o).value() == value();
    }
    @Override public int hashCode(){
      return 127 * "String_Node_Str".hashCode() ^ value;
    }
  }
;
}
Program: 60620
Project: 60620
Buggy source:
void writeClass() throws IOException {
  out.writePackageHeader();
  out.writeImport(Reflection.class);
  out.writeImport(ConstructionProxy.class);
  out.writeImport(InvocationTargetException.class);
  out.writeImport(Parameter.class);
  out.writeImport(List.class);
  out.writeImport(Member.class);
  out.writeImport(Parameter.class);
  out.writeImport(Nullability.class);
  out.writeImport(Arrays.class);
  out.writeImport(SuppressWarnings.class);
  out.writeImport(Key.class);
  out.writeImport(IllegalArgumentException.class);
  out.writeImport(Object.class);
  for (  Map.Entry<Class<?>,ConstructionProxy<?>> entry : constructionProxies.entrySet()) {
    out.writeImport(entry.getKey());
    for (    Parameter<?> parameter : entry.getValue().getParameters()) {
      out.writeImport(parameter.getKey().getTypeLiteral().getType());
    }
  }
  out.writeLine();
  out.openScope("String_Node_Str",generatedClassSimpleName());
  out.writeLine();
  writeGetConstructionProxy();
  out.writeLine();
  out.closeScope("String_Node_Str");
}

Fixed version (ground truth):
void writeClass() throws IOException {
  out.writePackageHeader();
  out.writeImport(Reflection.class);
  out.writeImport(ConstructionProxy.class);
  out.writeImport(InvocationTargetException.class);
  out.writeImport(Parameter.class);
  out.writeImport(List.class);
  out.writeImport(Member.class);
  out.writeImport(Parameter.class);
  out.writeImport(Nullability.class);
  out.writeImport(Arrays.class);
  out.writeImport(SuppressWarnings.class);
  out.writeImport(Key.class);
  out.writeImport(IllegalArgumentException.class);
  out.writeImport(Object.class);
  for (  Map.Entry<Class<?>,ConstructionProxy<?>> entry : constructionProxies.entrySet()) {
    out.writeImport(entry.getKey());
    for (    Parameter<?> parameter : entry.getValue().getParameters()) {
      out.writeImport(parameter.getKey().getTypeLiteral().getType());
    }
  }
  out.writeLine().openScope("String_Node_Str",generatedClassSimpleName(),Reflection.class).writeLine();
  writeGetConstructionProxy();
  out.writeLine().closeScope("String_Node_Str");
}
Program: 60621
Project: 60621
Buggy source:
public void openScope(String format,Object... args) throws IOException {
  writeLine(format,args);
  indent++;
}

Fixed version (ground truth):
public JavaCodeGenerator openScope(String format,Object... args) throws IOException {
  writeLine(format,args);
  indent++;
  return this;
}
Program: 60622
Project: 60622
Buggy source:
public void closeScope(String format,Object... args) throws IOException {
  indent--;
  writeLine(format,args);
}

Fixed version (ground truth):
public JavaCodeGenerator closeScope(String format,Object... args) throws IOException {
  indent--;
  return writeLine(format,args);
}
Program: 60623
Project: 60623
Buggy source:
public void writeLine() throws IOException {
  writer.append("String_Node_Str");
}

Fixed version (ground truth):
public JavaCodeGenerator writeLine() throws IOException {
  writer.append("String_Node_Str");
  return this;
}
Program: 60625
Project: 60625
Buggy source:
public Void call(InternalContext context){
  InjectionPoint<?> injectionPoint=InjectionPoint.newInstance(key,context.getInjectorImpl());
  context.setInjectionPoint(injectionPoint);
  try {
    factory.get(context,injectionPoint);
    return null;
  }
 catch (  ProvisionException provisionException) {
    provisionException.addContext(injectionPoint);
    throw provisionException;
  }
 finally {
    context.setInjectionPoint(null);
  }
}

Fixed version (ground truth):
public Void call(InternalContext context){
  InjectionPoint<?> injectionPoint=InjectionPoint.newInstance(key,context.getInjector());
  context.setInjectionPoint(injectionPoint);
  try {
    factory.get(context,injectionPoint);
    return null;
  }
 catch (  ProvisionException provisionException) {
    provisionException.addContext(injectionPoint);
    throw provisionException;
  }
 finally {
    context.setInjectionPoint(null);
  }
}
Program: 60626
Project: 60626
Buggy source:
@SuppressWarnings("String_Node_Str") <T>ConstructionContext<T> getConstructionContext(Object key){
  if (constructionContexts == null) {
    constructionContexts=new HashMap<Object,ConstructionContext<?>>();
    ConstructionContext<T> constructionContext=new ConstructionContext<T>();
    constructionContexts.put(key,constructionContext);
    return constructionContext;
  }
 else {
    ConstructionContext<T> constructionContext=(ConstructionContext<T>)constructionContexts.get(key);
    if (constructionContext == null) {
      constructionContext=new ConstructionContext<T>();
      constructionContexts.put(key,constructionContext);
    }
    return constructionContext;
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public <T>ConstructionContext<T> getConstructionContext(Object key){
  if (constructionContexts == null) {
    constructionContexts=new HashMap<Object,ConstructionContext<?>>();
    ConstructionContext<T> constructionContext=new ConstructionContext<T>();
    constructionContexts.put(key,constructionContext);
    return constructionContext;
  }
 else {
    ConstructionContext<T> constructionContext=(ConstructionContext<T>)constructionContexts.get(key);
    if (constructionContext == null) {
      constructionContext=new ConstructionContext<T>();
      constructionContexts.put(key,constructionContext);
    }
    return constructionContext;
  }
}
Program: 60627
Project: 60627
Buggy source:
InternalContext(InjectorImpl injector){
  this.injector=injector;
}

Fixed version (ground truth):
public InternalContext(InjectorImpl injector){
  this.injector=injector;
}
Program: 60628
Project: 60628
Buggy source:
public void toInstance(final T instance){
  nonNull(instance,"String_Node_Str");
  checkNotTargetted();
  bindTarget=new AbstractTarget<T>(){
    public ScopedBindingBuilder execute(    LinkedBindingBuilder<T> linkedBindingBuilder){
      linkedBindingBuilder.toInstance(instance);
      return null;
    }
    @Override public T get(){
      return instance;
    }
    public <V>V acceptVisitor(    Visitor<T,V> visitor){
      return visitor.visitToInstance(instance);
    }
    @Override public String toString(){
      return "String_Node_Str" + instance;
    }
  }
;
}

Fixed version (ground truth):
public void toInstance(final T instance){
  nonNull(instance,ErrorMessages.CANNOT_BIND_TO_NULL_INSTANCE);
  checkNotTargetted();
  bindTarget=new AbstractTarget<T>(){
    public ScopedBindingBuilder execute(    LinkedBindingBuilder<T> linkedBindingBuilder){
      linkedBindingBuilder.toInstance(instance);
      return null;
    }
    @Override public T get(){
      return instance;
    }
    public <V>V acceptVisitor(    Visitor<T,V> visitor){
      return visitor.visitToInstance(instance);
    }
    @Override public String toString(){
      return "String_Node_Str" + instance;
    }
  }
;
}
Program: 60629
Project: 60629
Buggy source:
@Override public Boolean visitBindConstant(BindConstantCommand command){
  Object value=command.getTarget().get();
  if (value == null) {
    addError(command.getSource(),ErrorMessages.MISSING_CONSTANT_VALUE);
  }
  validateKey(command.getSource(),command.getKey());
  ConstantFactory<Object> factory=new ConstantFactory<Object>(value);
  putBinding(new ContantBindingImpl<Object>(injector,command.getKey(),command.getSource(),factory,value));
  return true;
}

Fixed version (ground truth):
@Override public Boolean visitBindConstant(BindConstantCommand command){
  Object value=command.getTarget().get();
  if (value == null) {
    addError(command.getSource(),ErrorMessages.MISSING_CONSTANT_VALUE);
  }
  validateKey(command.getSource(),command.getKey());
  ConstantFactory<Object> factory=new ConstantFactory<Object>(value);
  putBinding(new ConstantBindingImpl<Object>(injector,command.getKey(),command.getSource(),factory,value));
  return true;
}
Program: 60630
Project: 60630
Buggy source:
public Void visitUntargetted(){
  Type type=key.getTypeLiteral().getType();
  if (key.hasAnnotationType() || !(type instanceof Class<?>)) {
    addError(source,ErrorMessages.MISSING_IMPLEMENTATION);
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
  BindingImpl<T> binding=injector.createBindingFromType(clazz,scope,source);
  if (binding == null) {
    addError(source,ErrorMessages.CANNOT_INJECT_ABSTRACT_TYPE,clazz);
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  createBinding(source,shouldPreload,binding);
  return null;
}

Fixed version (ground truth):
public Void visitUntargetted(){
  final Type type=key.getTypeLiteral().getType();
  if (key.hasAnnotationType() || !(type instanceof Class<?>)) {
    addError(source,ErrorMessages.MISSING_IMPLEMENTATION);
    createBinding(source,shouldPreload,invalidBinding(injector,key,source));
    return null;
  }
  untargettedBindings.add(new Runnable(){
    public void run(){
      @SuppressWarnings("String_Node_Str") Class<T> clazz=(Class<T>)type;
      BindingImpl<T> binding=injector.createBindingFromType(clazz,scope,source);
      if (binding == null) {
        injector.errorHandler.handle(source,ErrorMessages.CANNOT_INJECT_ABSTRACT_TYPE,clazz);
        createBinding(source,shouldPreload,invalidBinding(injector,key,source));
        return;
      }
      createBinding(source,shouldPreload,binding);
    }
  }
);
  return null;
}
Program: 60632
Project: 60632
Buggy source:
/** 
 * Builds the injector.
 */
private void buildCoreInjector(){
  new ErrorsCommandProcessor().processCommands(commands,configurationErrorHandler);
  BindInterceptorCommandProcessor bindInterceptorCommandProcessor=new BindInterceptorCommandProcessor();
  bindInterceptorCommandProcessor.processCommands(commands,configurationErrorHandler);
  injector.constructionProxyFactory=bindInterceptorCommandProcessor.createProxyFactory();
  stopwatch.resetAndLog("String_Node_Str");
  new ScopesCommandProcessor(injector.scopes).processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
  new ConvertToTypesCommandProcessor(injector.converters).processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
  bindCommandProcesor=new BindCommandProcessor(injector,injector.scopes,stage,injector.explicitBindings,injector.outstandingInjections);
  bindCommandProcesor.processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
  injector.index();
  stopwatch.resetAndLog("String_Node_Str");
  requestStaticInjectionCommandProcessor=new RequestStaticInjectionCommandProcessor();
  requestStaticInjectionCommandProcessor.processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Builds the injector.
 */
private void buildCoreInjector(){
  new ErrorsCommandProcessor().processCommands(commands,configurationErrorHandler);
  BindInterceptorCommandProcessor bindInterceptorCommandProcessor=new BindInterceptorCommandProcessor();
  bindInterceptorCommandProcessor.processCommands(commands,configurationErrorHandler);
  injector.constructionProxyFactory=bindInterceptorCommandProcessor.createProxyFactory();
  stopwatch.resetAndLog("String_Node_Str");
  new ScopesCommandProcessor(injector.scopes).processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
  new ConvertToTypesCommandProcessor(injector.converters).processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
  bindCommandProcesor=new BindCommandProcessor(injector,injector.scopes,stage,injector.explicitBindings,injector.outstandingInjections);
  bindCommandProcesor.processCommands(commands,configurationErrorHandler);
  bindCommandProcesor.createUntargettedBindings();
  stopwatch.resetAndLog("String_Node_Str");
  injector.index();
  stopwatch.resetAndLog("String_Node_Str");
  requestStaticInjectionCommandProcessor=new RequestStaticInjectionCommandProcessor();
  requestStaticInjectionCommandProcessor.processCommands(commands,configurationErrorHandler);
  stopwatch.resetAndLog("String_Node_Str");
}
Program: 60633
Project: 60633
Buggy source:
protected void configure(){
  bind(BoundFirst.class);
  bind(BoundSecond.class).to(BoundSecondImpl.class);
}

Fixed version (ground truth):
protected void configure(){
  bind(A.class).asEagerSingleton();
  bind(B.class).asEagerSingleton();
}
Program: 60634
Project: 60634
Buggy source:
/** 
 * Creates a construction proxy given a class and parameter types.
 */
<T>ConstructionProxy<T> createConstructionProxy(Class<?> clazz,Class[] parameterTypes){
  FastClass fastClass=GuiceFastClass.create(clazz);
  final FastConstructor fastConstructor=fastClass.getConstructor(parameterTypes);
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,fastConstructor.getJavaConstructor());
    }
    public Member getMember(){
      return fastConstructor.getJavaConstructor();
    }
  }
;
}

Fixed version (ground truth):
/** 
 * Creates a construction proxy given a class and parameter types.
 */
private <T>ConstructionProxy<T> createConstructionProxy(final Class<?> clazz,final Constructor standardConstructor){
  FastClass fastClass=GuiceFastClass.create(clazz);
  final FastConstructor fastConstructor=fastClass.getConstructor(standardConstructor.getParameterTypes());
  return new ConstructionProxy<T>(){
    @SuppressWarnings("String_Node_Str") public T newInstance(    Object... arguments) throws InvocationTargetException {
      return (T)fastConstructor.newInstance(arguments);
    }
    public List<Parameter<?>> getParameters(){
      return Parameter.forConstructor(errorHandler,fastConstructor.getJavaConstructor());
    }
    public Member getMember(){
      return standardConstructor;
    }
  }
;
}
Program: 60635
Project: 60635
Buggy source:
public Member getMember(){
  return fastConstructor.getJavaConstructor();
}

Fixed version (ground truth):
public Member getMember(){
  return standardConstructor;
}
Program: 60636
Project: 60636
Buggy source:
Member getMember();

Fixed version (ground truth):
/** 
 * Returns the injected method or constructor. If the injected member is synthetic (such as generated code for method interception), the natural constructor is returned.
 */
Member getMember();
Program: 60637
Project: 60637
Buggy source:
public void testBindingOrderAndScopes(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(A.class).asEagerSingleton();
      bind(B.class).asEagerSingleton();
    }
  }
);
  A a=injector.getInstance(A.class);
  assertSame(a.first,a.second);
}

Fixed version (ground truth):
public void testBindingOrderAndScopes(){
  Injector injector=Guice.createInjector(new AbstractModule(){
    protected void configure(){
      bind(A.class);
      bind(B.class).asEagerSingleton();
    }
  }
);
  assertSame(injector.getInstance(A.class).b,injector.getInstance(A.class).b);
}
Program: 60638
Project: 60638
Buggy source:
protected void configure(){
  bind(A.class).asEagerSingleton();
  bind(B.class).asEagerSingleton();
}

Fixed version (ground truth):
protected void configure(){
  bind(A.class);
  bind(B.class).asEagerSingleton();
}
Program: 60640
Project: 60640
Buggy source:
public Void visitToProvider(Provider<? extends T> provider){
  InternalFactory<? extends T> factory=new InternalFactoryToProviderAdapter<T>(provider,source);
  registerInstanceForInjection(provider);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  createBinding(source,shouldPreload,new ProviderInstanceBindingImpl<T>(injector,key,source,scopedFactory,scope,provider));
  return null;
}

Fixed version (ground truth):
public Void visitToProvider(Provider<? extends T> provider){
  InternalFactoryToProviderAdapter<? extends T> factory=new InternalFactoryToProviderAdapter<T>(provider,source);
  outstandingInjections.put(provider,null);
  InternalFactory<? extends T> scopedFactory=Scopes.scope(key,injector,factory,scope);
  createBinding(source,shouldPreload,new ProviderInstanceBindingImpl<T>(injector,key,source,scopedFactory,scope,provider));
  return null;
}
Program: 60641
Project: 60641
Buggy source:
private <T>void createBinding(Object source,boolean shouldPreload,BindingImpl<T> binding){
  putBinding(binding);
  if (binding.getScope() == Scopes.SINGLETON) {
    if (stage == Stage.PRODUCTION || shouldPreload) {
      preloaders.add(new BindingPreloader(binding.key,binding.internalFactory));
    }
  }
 else {
    if (shouldPreload) {
      addError(source,ErrorMessages.PRELOAD_NOT_ALLOWED);
    }
  }
}

Fixed version (ground truth):
private <T>void createBinding(Object source,boolean shouldPreload,BindingImpl<T> binding){
  putBinding(binding);
  if (binding.getScope() == Scopes.SINGLETON) {
    if (stage == Stage.PRODUCTION || shouldPreload) {
      eagerSingletonCreators.add(new EagerSingletonCreator(binding.key,binding.internalFactory));
    }
  }
 else {
    if (shouldPreload) {
      addError(source,ErrorMessages.PRELOAD_NOT_ALLOWED);
    }
  }
}
Program: 60642
Project: 60642
Buggy source:
BindCommandProcessor(InjectorImpl injector,Map<Class<? extends Annotation>,Scope> scopes,Stage stage,Map<Key<?>,BindingImpl<?>> bindings){
  this.injector=injector;
  this.scopes=scopes;
  this.stage=stage;
  this.bindings=bindings;
}

Fixed version (ground truth):
BindCommandProcessor(InjectorImpl injector,Map<Class<? extends Annotation>,Scope> scopes,Stage stage,Map<Key<?>,BindingImpl<?>> bindings,Map<Object,Void> outstandingInjections){
  this.injector=injector;
  this.scopes=scopes;
  this.stage=stage;
  this.bindings=bindings;
  this.outstandingInjections=outstandingInjections;
}