Java 类com.google.inject.spi.InjectionPoint 实例源码

private void analyzeImplementation(final TypeLiteral<?> type, boolean ignoreConstructor)
{
    if( !scannedTypes.contains(type) )
    {
        try
        {
            if( (type.getRawType().getModifiers() & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0 )
            {
                analyzeInjectionPoints(InjectionPoint.forInstanceMethodsAndFields(type));
                if( !ignoreConstructor )
                {
                    analyzeDependencies(InjectionPoint.forConstructorOf(type).getDependencies());
                }
            }
        }
        catch( ConfigurationException ce )
        {
            errors.merge(ce.getErrorMessages());
        }
        scannedTypes.add(type);
    }
}

private static boolean checkOnlyAcceptsPlayer(Class<? extends JCmd> executor) {
    for (InjectionPoint point : InjectionPoint.forInstanceMethodsAndFields(executor)) {
        if (!(point.getMember() instanceof Field))
            continue;

        Key<?> key = point.getDependencies().get(0).getKey();
        if (key.getTypeLiteral().getRawType().equals(Player.class)) {
            return true;
        }
    }

    return false;
}

public static PassType newPassType(String name, Class<? extends Pass> cls)
{
    ImmutableList.Builder<TypeLiteral<?>> inputs = ImmutableList.builder();
    ImmutableList.Builder<TypeLiteral<?>> outputs = ImmutableList.builder();
    InjectionPoint passCtor = InjectionPoint.forConstructorOf(cls);
    for (Dependency<?> dep : passCtor.getDependencies()) {
        Key key = dep.getKey();
        if (key.getAnnotation() instanceof PassInput) {
            inputs.add(key.getTypeLiteral());
        }
        else if (key.getAnnotation() instanceof PassOutput) {
            checkState(key.getTypeLiteral().getRawType() == Consumer.class);
            ParameterizedType parameterized = (ParameterizedType) key.getTypeLiteral().getType();
            java.lang.reflect.Type outputType = parameterized.getActualTypeArguments()[0];
            outputs.add(TypeLiteral.get(outputType));
        }
    }
    return new PassType(name, cls, inputs.build(), outputs.build());
}

void addStaticInjectionRequest(Class<?> type, Object source) {
  assertNotFinalized();
  staticInjectionRequests.add(type);

  // Calculate required bindings and add to dependencies
  for (InjectionPoint injectionPoint : InjectionPoint.forStaticMethodsAndFields(type)) {
    Member member = injectionPoint.getMember();
    if (member instanceof Method) {
      addDependencies(guiceUtil.getDependencies(Dependency.GINJECTOR,
          MethodLiteral.get((Method) member, TypeLiteral.get(member.getDeclaringClass()))));
    } else if (member instanceof Field) {
      FieldLiteral<?> field =
          FieldLiteral.get((Field) member, TypeLiteral.get(member.getDeclaringClass()));
      Key<?> key = guiceUtil.getKey(field);
      addDependency(new Dependency(
          Dependency.GINJECTOR, key, guiceUtil.isOptional(field), false,
          source.toString()));
    }
  }
}

private void injectValues(final Object target, final boolean sharedFields) throws IllegalAccessException {
    for (InjectionPoint point : injectionPoints) {
        if (!(point.getMember() instanceof Field)) {
            throw new GuiceyExtensionException("Method injection is not supported; use field injection instead");
        }

        final Field field = (Field) point.getMember();
        if (field.isAnnotationPresent(Shared.class) != sharedFields) {
            continue;
        }

        final Object value = externalRuleAdapter.getInjector().getInstance(point.getDependencies().get(0).getKey());
        field.setAccessible(true);
        field.set(target, value);
    }
}

InternalProviderInstanceBindingImpl(
    InjectorImpl injector,
    Key<T> key,
    Object source,
    Factory<T> originalFactory,
    InternalFactory<? extends T> scopedFactory,
    Scoping scoping) {
  super(
      injector,
      key,
      source,
      scopedFactory,
      scoping,
      originalFactory,
      ImmutableSet.<InjectionPoint>of());
  this.originalFactory = originalFactory;
}

public void toInstance(T instance) {
  checkNotTargetted();

  // lookup the injection points, adding any errors to the binder's errors list
  Set<InjectionPoint> injectionPoints;
  if (instance != null) {
    try {
      injectionPoints = InjectionPoint.forInstanceMethodsAndFields(instance.getClass());
    } catch (ConfigurationException e) {
      copyErrorsToBinder(e);
      injectionPoints = e.getPartialValue();
    }
  } else {
    binder.addError(BINDING_TO_NULL);
    injectionPoints = ImmutableSet.of();
  }

  BindingImpl<T> base = getBinding();
  setBinding(new InstanceBindingImpl<T>(
      base.getSource(), base.getKey(), Scoping.EAGER_SINGLETON, injectionPoints, instance));
}

public void testInterceptOneMethod()
    throws NoSuchMethodException, InvocationTargetException, ErrorsException {
  SimpleInterceptor interceptor = new SimpleInterceptor();

  aspects.add(new MethodAspect(only(Bar.class), annotatedWith(Intercept.class), interceptor));

  ConstructionProxy<Foo> fooFactory
      = new ProxyFactory<Foo>(InjectionPoint.forConstructorOf(Foo.class), aspects).create();
  ConstructionProxy<Bar> barFactory
      = new ProxyFactory<Bar>(InjectionPoint.forConstructorOf(Bar.class), aspects).create();

  Foo foo = fooFactory.newInstance();
  Bar bar = barFactory.newInstance();

  foo.foo();
  assertTrue(foo.fooCalled);
  assertFalse(interceptor.invoked);

  bar.bar();
  assertTrue(bar.barCalled);
  assertFalse(interceptor.invoked);

  bar.intercepted();
  assertTrue(bar.interceptedCalled);
  assertTrue(interceptor.invoked);
}

public static void formatInjectionPoint(Formatter formatter, Dependency<?> dependency,
    InjectionPoint injectionPoint, ElementSource elementSource) {
  Member member = injectionPoint.getMember();
  Class<? extends Member> memberType = Classes.memberType(member);

  if (memberType == Field.class) {
    dependency = injectionPoint.getDependencies().get(0);
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for field at %s%n", StackTraceElements.forMember(member));

  } else if (dependency != null) {
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for parameter %s at %s%n",
        dependency.getParameterIndex(), StackTraceElements.forMember(member));

  } else {
    formatSource(formatter, injectionPoint.getMember());
  }
}

public void testTurkeyBaconProblemUsingToConstuctor() {
  Injector injector = Guice.createInjector(new AbstractModule() {
    @SuppressWarnings("unchecked")
    @Override
    public void configure() {
      bind(Bacon.class).to(UncookedBacon.class);
      bind(Bacon.class).annotatedWith(named("Turkey")).to(TurkeyBacon.class);
      bind(Bacon.class).annotatedWith(named("Cooked")).toConstructor(
          (Constructor)InjectionPoint.forConstructorOf(Bacon.class).getMember());
    }
  });
  Bacon bacon = injector.getInstance(Bacon.class);
  assertEquals(Food.PORK, bacon.getMaterial());
  assertFalse(bacon.isCooked());

  Bacon turkeyBacon = injector.getInstance(Key.get(Bacon.class, named("Turkey")));
  assertEquals(Food.TURKEY, turkeyBacon.getMaterial());
  assertTrue(turkeyBacon.isCooked());

  Bacon cookedBacon = injector.getInstance(Key.get(Bacon.class, named("Cooked")));
  assertEquals(Food.PORK, cookedBacon.getMaterial());
  assertTrue(cookedBacon.isCooked());    
}

@Override
public void toInstance(T instance) {
  checkNotTargetted();

  // lookup the injection points, adding any errors to the binder's errors list
  Set<InjectionPoint> injectionPoints;
  if (instance != null) {
    try {
      injectionPoints = InjectionPoint.forInstanceMethodsAndFields(instance.getClass());
    } catch (ConfigurationException e) {
      copyErrorsToBinder(e);
      injectionPoints = e.getPartialValue();
    }
  } else {
    binder.addError(BINDING_TO_NULL);
    injectionPoints = ImmutableSet.of();
  }

  BindingImpl<T> base = getBinding();
  setBinding(
      new InstanceBindingImpl<T>(
          base.getSource(), base.getKey(), Scoping.EAGER_SINGLETON, injectionPoints, instance));
}

private <T> BindingImpl<MembersInjector<T>> createMembersInjectorBinding(
    Key<MembersInjector<T>> key, Errors errors) throws ErrorsException {
  Type membersInjectorType = key.getTypeLiteral().getType();
  if (!(membersInjectorType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawMembersInjector().toException();
  }

  @SuppressWarnings("unchecked") // safe because T came from Key<MembersInjector<T>>
  TypeLiteral<T> instanceType = (TypeLiteral<T>) TypeLiteral.get(
      ((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
  MembersInjector<T> membersInjector = membersInjectorStore.get(instanceType, errors);

  InternalFactory<MembersInjector<T>> factory = new ConstantFactory<MembersInjector<T>>(
      Initializables.of(membersInjector));


  return new InstanceBindingImpl<MembersInjector<T>>(this, key, SourceProvider.UNKNOWN_SOURCE,
      factory, ImmutableSet.<InjectionPoint>of(), membersInjector);
}

/** Returns the injectors for the specified injection points. */
ImmutableList<SingleMemberInjector> getInjectors(
    Set<InjectionPoint> injectionPoints, Errors errors) {
  List<SingleMemberInjector> injectors = Lists.newArrayList();
  for (InjectionPoint injectionPoint : injectionPoints) {
    try {
      Errors errorsForMember =
          injectionPoint.isOptional()
              ? new Errors(injectionPoint)
              : errors.withSource(injectionPoint);
      SingleMemberInjector injector =
          injectionPoint.getMember() instanceof Field
              ? new SingleFieldInjector(this.injector, injectionPoint, errorsForMember)
              : new SingleMethodInjector(this.injector, injectionPoint, errorsForMember);
      injectors.add(injector);
    } catch (ErrorsException ignoredForNow) {
      // ignored for now
    }
  }
  return ImmutableList.copyOf(injectors);
}

private <T> BindingImpl<MembersInjector<T>> createMembersInjectorBinding(
    Key<MembersInjector<T>> key, Errors errors) throws ErrorsException {
  Type membersInjectorType = key.getTypeLiteral().getType();
  if (!(membersInjectorType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawMembersInjector().toException();
  }

  @SuppressWarnings("unchecked") // safe because T came from Key<MembersInjector<T>>
  TypeLiteral<T> instanceType =
      (TypeLiteral<T>)
          TypeLiteral.get(((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
  MembersInjector<T> membersInjector = membersInjectorStore.get(instanceType, errors);

  InternalFactory<MembersInjector<T>> factory =
      new ConstantFactory<MembersInjector<T>>(Initializables.of(membersInjector));

  return new InstanceBindingImpl<MembersInjector<T>>(
      this,
      key,
      SourceProvider.UNKNOWN_SOURCE,
      factory,
      ImmutableSet.<InjectionPoint>of(),
      membersInjector);
}

/**
 * Registers an instance for member injection when that step is performed.
 *
 * @param instance an instance that optionally has members to be injected (each annotated with
 *      @Inject).
 * @param binding the binding that caused this initializable to be created, if it exists.
 * @param source the source location that this injection was requested
 */
<T> Initializable<T> requestInjection(InjectorImpl injector, T instance, Binding<T> binding,
    Object source, Set<InjectionPoint> injectionPoints) {
  checkNotNull(source);

  ProvisionListenerStackCallback<T> provisionCallback =
      binding == null ? null : injector.provisionListenerStore.get(binding);

  // short circuit if the object has no injections or listeners.
  if (instance == null || (injectionPoints.isEmpty()
      && !injector.membersInjectorStore.hasTypeListeners()
      && (provisionCallback == null || !provisionCallback.hasListeners()))) {
    return Initializables.of(instance);
  }

  InjectableReference<T> initializable = new InjectableReference<T>(
      injector, instance, binding == null ? null : binding.getKey(), provisionCallback, source);
  pendingInjection.put(instance, initializable);
  return initializable;
}

private static void formatInjectionPoint(
    Formatter formatter,
    Dependency<?> dependency,
    InjectionPoint injectionPoint,
    ElementSource elementSource) {
  Member member = injectionPoint.getMember();
  Class<? extends Member> memberType = Classes.memberType(member);

  if (memberType == Field.class) {
    dependency = injectionPoint.getDependencies().get(0);
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for field at %s%n", StackTraceElements.forMember(member));

  } else if (dependency != null) {
    formatter.format("  while locating %s%n", convert(dependency.getKey(), elementSource));
    formatter.format("    for %s%n", formatParameter(dependency));

  } else {
    formatSource(formatter, injectionPoint.getMember());
  }
}

void validate() {
  Errors errorsForMember = errors.withSource(source);
  Set<InjectionPoint> injectionPoints;
  try {
    injectionPoints = request.getInjectionPoints();
  } catch (ConfigurationException e) {
    errorsForMember.merge(e.getErrorMessages());
    injectionPoints = e.getPartialValue();
  }
  if (injectionPoints != null) {
    memberInjectors =
        injector.membersInjectorStore.getInjectors(injectionPoints, errorsForMember);
  } else {
    memberInjectors = ImmutableList.of();
  }

  errors.merge(errorsForMember);
}

/**
 * @deprecated This method returns an empty scanner since the preexisting functionality is
 *     installed by default.
 */
@Deprecated
public static ModuleAnnotatedMethodScanner scanner() {
  return new ModuleAnnotatedMethodScanner() {
    @Override
    public Set<? extends Class<? extends Annotation>> annotationClasses() {
      return ImmutableSet.of();
    }

    @Override
    public <T> Key<T> prepareMethod(
        Binder binder, Annotation annotation, Key<T> key, InjectionPoint injectionPoint) {
      throw new IllegalStateException("Unexpected annotation: " + annotation);
    }
  };
}

public void testInterceptOneMethod()
    throws NoSuchMethodException, InvocationTargetException, ErrorsException {
  SimpleInterceptor interceptor = new SimpleInterceptor();

  aspects.add(new MethodAspect(only(Bar.class), annotatedWith(Intercept.class), interceptor));

  ConstructionProxy<Foo> fooFactory =
      new ProxyFactory<Foo>(InjectionPoint.forConstructorOf(Foo.class), aspects).create();
  ConstructionProxy<Bar> barFactory =
      new ProxyFactory<Bar>(InjectionPoint.forConstructorOf(Bar.class), aspects).create();

  Foo foo = fooFactory.newInstance();
  Bar bar = barFactory.newInstance();

  foo.foo();
  assertTrue(foo.fooCalled);
  assertFalse(interceptor.invoked);

  bar.bar();
  assertTrue(bar.barCalled);
  assertFalse(interceptor.invoked);

  bar.intercepted();
  assertTrue(bar.interceptedCalled);
  assertTrue(interceptor.invoked);
}

public void testMultipleInterceptors()
    throws NoSuchMethodException, InvocationTargetException, ErrorsException {
  DoubleInterceptor doubleInterceptor = new DoubleInterceptor();
  CountingInterceptor countingInterceptor = new CountingInterceptor();

  aspects.add(new MethodAspect(any(), any(), doubleInterceptor, countingInterceptor));
  ProxyFactory<Counter> factory =
      new ProxyFactory<Counter>(InjectionPoint.forConstructorOf(Counter.class), aspects);

  ConstructionProxy<Counter> constructor = factory.create();

  Counter counter = constructor.newInstance();
  counter.inc();
  assertEquals(2, counter.count);
  assertEquals(2, countingInterceptor.count);
}

public void testLinkedAndInstanceBindings() throws Exception {
  grapher.graph(Guice.createInjector(new AbstractModule() {
      @Override protected void configure() {
        bind(IA.class).to(A.class);
        bind(IA.class).annotatedWith(Ann.class).to(A.class);
        bind(String.class).toInstance(TEST_STRING);
      }
  }));

  Set<Node> expectedNodes =
      ImmutableSet.<Node>of(iaNode, iaAnnNode, aNode, stringNode, stringInstanceNode);
  Set<Edge> expectedEdges = ImmutableSet.<Edge>of(
      new BindingEdge(iaNode.getId(), aNode.getId(), BindingEdge.Type.NORMAL),
      new BindingEdge(iaAnnNode.getId(), aNode.getId(), BindingEdge.Type.NORMAL),
      new BindingEdge(stringNode.getId(), stringInstanceNode.getId(), BindingEdge.Type.NORMAL),
      new DependencyEdge(aNode.getId(), stringNode.getId(),
          InjectionPoint.forConstructor(A.class.getConstructor(String.class))));
  assertEquals(expectedNodes, grapher.nodes);
  assertEquals(expectedEdges, grapher.edges);
}

/**
 * Converts a binding for a {@code Key<TypeLiteral<T>>} to the value {@code TypeLiteral<T>}. It's
 * a bit awkward because we have to pull out the inner type in the type literal.
 */
private <T> BindingImpl<TypeLiteral<T>> createTypeLiteralBinding(
    Key<TypeLiteral<T>> key, Errors errors) throws ErrorsException {
  Type typeLiteralType = key.getTypeLiteral().getType();
  if (!(typeLiteralType instanceof ParameterizedType)) {
    throw errors.cannotInjectRawTypeLiteral().toException();
  }

  ParameterizedType parameterizedType = (ParameterizedType) typeLiteralType;
  Type innerType = parameterizedType.getActualTypeArguments()[0];

  // this is unforunate. We don't support building TypeLiterals for type variable like 'T'. If
  // this proves problematic, we can probably fix TypeLiteral to support type variables
  if (!(innerType instanceof Class)
      && !(innerType instanceof GenericArrayType)
      && !(innerType instanceof ParameterizedType)) {
    throw errors.cannotInjectTypeLiteralOf(innerType).toException();
  }

  @SuppressWarnings("unchecked") // by definition, innerType == T, so this is safe
  TypeLiteral<T> value = (TypeLiteral<T>) TypeLiteral.get(innerType);
  InternalFactory<TypeLiteral<T>> factory = new ConstantFactory<TypeLiteral<T>>(
      Initializables.of(value));
  return new InstanceBindingImpl<TypeLiteral<T>>(this, key, SourceProvider.UNKNOWN_SOURCE,
      factory, ImmutableSet.<InjectionPoint>of(), value);
}

/** Returns a set of dependencies that can be iterated over to clean up stray JIT bindings. */
Set<Dependency<?>> getInternalDependencies() {
  ImmutableSet.Builder<InjectionPoint> builder = ImmutableSet.builder();
  if(factory.constructorInjector == null) {
    builder.add(constructorInjectionPoint);
    // If the below throws, it's OK -- we just ignore those dependencies, because no one
    // could have used them anyway.
    try {
      builder.addAll(InjectionPoint.forInstanceMethodsAndFields(constructorInjectionPoint.getDeclaringType()));
    } catch(ConfigurationException ignored) {}
  } else {
    builder.add(getConstructor())
           .addAll(getInjectableMembers());
  }

  return Dependency.forInjectionPoints(builder.build());
}

/**
 * Return all direct dependencies injected into the given type
 */
public static Stream<Dependency<?>> dependencies(Class<?> type) {
    return Stream.concat(
        Stream.of(InjectionPoint.forConstructorOf(type)),
        InjectionPoint.forInstanceMethodsAndFields(type).stream()
    ).flatMap(ip -> ip.getDependencies().stream());
}

private <D> InjectableMethod(@Nullable TypeLiteral<D> targetType, @Nullable D target, Method method, @Nullable T result) {
    final Errors errors = new Errors(method);

    if(Members.isStatic(method)) {
        checkArgument(target == null);
    } else {
        checkArgument(target != null);
    }

    targetType = targetType(targetType, target, method);

    checkArgument(method.getDeclaringClass().isAssignableFrom(targetType.getRawType()));

    this.method = method;
    this.dependencies = ImmutableSet.copyOf(InjectionPoint.forMethod(method, targetType).getDependencies());

    if(result != null) {
        this.result = result;
        this.providedKey = Keys.forInstance(result);
    } else {
        final TypeLiteral<T> returnType = (TypeLiteral<T>) targetType.getReturnType(method);
        if(!Void.class.equals(returnType.getRawType())) {
            final Annotation qualifier = Annotations.findBindingAnnotation(errors, method, method.getAnnotations());
            this.result = null;
            this.providedKey = Keys.get(returnType, qualifier);
        } else {
            this.result = (T) this;
            this.providedKey = Keys.forInstance(this.result);
        }
    }

    this.scope = Annotations.findScopeAnnotation(errors, method.getAnnotations());

    MethodHandle handle = MethodHandleUtils.privateUnreflect(method);
    if(target != null) {
        handle = handle.bindTo(target);
    }
    this.handle = handle;
}

public DependencyCollector log(Logger logger, Level level) {
    logger.log(level, "Dumping all dependencies:");
    for(Map.Entry<TypeLiteral<?>, Collection<InjectionPoint>> entry : injectionPointsByType().asMap().entrySet()) {
        logger.log(level, entry.getKey().toString());
        for(InjectionPoint ip : entry.getValue()) {
            logger.log(level, "  " + ip.getMember());
            for(Dependency<?> dep : dependenciesByInjectionPoint().get(ip)) {
                logger.log(level, "    " + dep);
            }
        }
    }
    return this;
}

@Inject public MemberInjectingFactory(TypeLiteral<T> type, MembersInjector<T> injector) {
    this.type = type;
    this.injector = injector;
    this.injectionPoint = InjectionPoint.forConstructorOf(type);
    this.constructor = (Constructor<T>) injectionPoint.getMember();
    this.constructor.setAccessible(true);

    dependencies.addAll(Dependency.forInjectionPoints(InjectionPoint.forInstanceMethodsAndFields(type)));
}

public static void checkInjectableCGLibProxyBase(Class<?> cls) {
    InjectionPoint.forInstanceMethodsAndFields(cls).forEach(ip -> {
        if(ip.getMember() instanceof Method && !Modifier.isPrivate(ip.getMember().getModifiers())) {
            // CGLib proxies override all non-private methods on the base class,
            // and do not copy method annotations, so Guice will not find the
            // @Inject annotation on the base method. Declaring the method
            // private works around this. The proxy will not try to override
            // private methods, and Guice can find them just fine.
            throw new MethodFormException(
                (Method) ip.getMember(),
                "Injected method on CGLib proxied class must be private (see exception site for details)"
            );
        }
    });
}

private void analyzeDependencies(final Collection<Dependency<?>> dependencies)
{
    for( final Dependency<?> d : dependencies )
    {
        final Key<?> key = d.getKey();
        InjectionPoint injectionPoint = d.getInjectionPoint();
        if( injectionPoint != null && injectionPoint.isOptional() )
        {
            continue;
        }
        if( key.getAnnotationType() == Assisted.class )
        {
            continue;
        }
        TypeLiteral<?> typeLiteral = key.getTypeLiteral();
        Class<?> rawType = typeLiteral.getRawType();
        if( rawType == Injector.class )
        {
            continue;
        }
        if( rawType == MembersInjector.class )
        {
            Key<?> injectedKey = key
                .ofType(((ParameterizedType) typeLiteral.getType()).getActualTypeArguments()[0]);
            dependentKeys.add(injectedKey);
            analyzeImplementation(injectedKey.getTypeLiteral(), true);
        }
        else if( rawType == Provider.class )
        {
            dependentKeys.add(key.ofType(((ParameterizedType) typeLiteral.getType()).getActualTypeArguments()[0]));
        }
        else
        {
            dependentKeys.add(key);
        }
    }
}

public void analyzeInjectionPoints(final Set<InjectionPoint> points)
{
    for( final InjectionPoint p : points )
    {
        analyzeDependencies(p.getDependencies());
    }
}

@Override
public T get() {
    InjectionPoint ip = CURRENT_CONTEXT.get();
    if (ip != null) {
        return delegate().getInContext(ip);
    } else {
        return delegate().getInUnknownContext();
    }
}

ProviderInstanceAdapter(ContextSensitiveProvider<? extends T> instance) {
    this.instance = instance;

    Set<InjectionPoint> injectionPoints;
    try {
        injectionPoints = InjectionPoint.forInstanceMethodsAndFields(instance.getClass());
    } catch (ConfigurationException e) {
        // We can ignore the error, the earlier requestInjection(instance) call will have reported it
        injectionPoints = e.getPartialValue();
    }
    this.injectionPoints = injectionPoints;
}

/** Cleans up any state that may have been cached when constructing the JIT binding. */
private void removeFailedJitBinding(Binding<?> binding, InjectionPoint ip) {
  failedJitBindings.add(binding.getKey());
  jitBindings.remove(binding.getKey());
  membersInjectorStore.remove(binding.getKey().getTypeLiteral());
  provisionListenerStore.remove(binding);
  if(ip != null) {
    constructors.remove(ip);
  }
}

@Override
public Recursive getInContext(InjectionPoint injectionPoint) {
    Recursive result = new Recursive();
    membersInjector.injectMembers(result);
    result.self = injectionPoint.getDeclaringType().getRawType().getSimpleName();
    return result;
}

@Override
public <T> Key<T> prepareMethod(
    Binder binder, Annotation rawAnnotation, Key<T> key, InjectionPoint injectionPoint) {
  Method providesMethod = (Method) injectionPoint.getMember();
  Provides annotation = (Provides) rawAnnotation;
  if (providesMethod.isAnnotationPresent(IntoSet.class)) {
    return processSetBinding(binder, key);
  } else if (providesMethod.isAnnotationPresent(ElementsIntoSet.class)) {
    binder.addError("@ElementsIntoSet contributions are not suppored by Guice.", providesMethod);
    return key;
  } else if (providesMethod.isAnnotationPresent(IntoMap.class)) {
    /* TODO(cgruber) implement map bindings */
    binder.addError("Map bindings are not yet supported.");
    return key;
  }

  switch (annotation.type()) {
    case UNIQUE:
      return key;
    case SET:
      return processSetBinding(binder, key);
    case SET_VALUES:
      binder.addError(
          Type.SET_VALUES.name() + " contributions are not supported by Guice.", providesMethod);
      return key;
    default:
      binder.addError("Unknown @Provides type " + annotation.type() + ".", providesMethod);
      return key;
  }
}

@Override
protected void newDependencyEdge(DependencyEdge edge) {
  GraphvizEdge gedge = new GraphvizEdge(edge.getFromId(), edge.getToId());
  InjectionPoint fromPoint = edge.getInjectionPoint();
  if (fromPoint == null) {
    gedge.setTailPortId("header");
  } else {
    gedge.setTailPortId(portIdFactory.getPortId(fromPoint.getMember()));
  }
  gedge.setArrowHead(ImmutableList.of(ArrowType.NORMAL));
  gedge.setTailCompassPoint(CompassPoint.EAST);

  edges.add(gedge);
}

/**
 * Returns a new instance node for the given {@link Binding}.
 *
 * @param binding binding for the node to create
 * @param instance value of the instance
 * @return instance node for the given binding
 */
private <T extends Binding<?> & HasDependencies> InstanceNode newInstanceNode(
    T binding, Object instance) {
  Collection<Member> members = Lists.newArrayList();
  for (Dependency<?> dependency : binding.getDependencies()) {
    InjectionPoint injectionPoint = dependency.getInjectionPoint();

    if (injectionPoint != null) {
      members.add(injectionPoint.getMember());
    }
  }
  return new InstanceNode(
      NodeId.newInstanceId(binding.getKey()), binding.getSource(), instance, members);
}

/**
 * Visitor for {@link ConstructorBinding}s. These are for classes that Guice will instantiate to
 * satisfy injection requests.
 */
@Override
public Collection<Node> visit(ConstructorBinding<?> binding) {
  Collection<Member> members = Lists.newArrayList();
  members.add(binding.getConstructor().getMember());
  for (InjectionPoint injectionPoint : binding.getInjectableMembers()) {
    members.add(injectionPoint.getMember());
  }

  return ImmutableList.<Node>of(newImplementationNode(binding, members));
}

public void testLinkedAndInstanceBindings() throws Exception {
  grapher.graph(
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bind(IA.class).to(A.class);
              bind(IA.class).annotatedWith(Ann.class).to(A.class);
              bind(String.class).toInstance(TEST_STRING);
            }
          }));

  Set<Node> expectedNodes =
      ImmutableSet.<Node>of(iaNode, iaAnnNode, aNode, stringNode, stringInstanceNode);
  Set<Edge> expectedEdges =
      ImmutableSet.<Edge>of(
          new BindingEdge(iaNode.getId(), aNode.getId(), BindingEdge.Type.NORMAL),
          new BindingEdge(iaAnnNode.getId(), aNode.getId(), BindingEdge.Type.NORMAL),
          new BindingEdge(
              stringNode.getId(), stringInstanceNode.getId(), BindingEdge.Type.NORMAL),
          new DependencyEdge(
              aNode.getId(),
              stringNode.getId(),
              InjectionPoint.forConstructor(A.class.getConstructor(String.class))));
  assertEquals(expectedNodes, grapher.nodes);
  assertEquals(expectedEdges, grapher.edges);
}

public void testProviderBindings() throws Exception {
  final Wrapper<Provider<A2>> wrapper = new Wrapper<>();
  grapher.graph(
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              wrapper.value = getProvider(A2.class);
              bind(IA.class).toProvider(wrapper.value);
              bind(A2.class);
              bind(String.class).toInstance(TEST_STRING);
            }
          }));

  Node a2ProviderNode =
      new InstanceNode(
          NodeId.newInstanceId(Key.get(IA.class)),
          null,
          wrapper.value,
          ImmutableList.<Member>of());
  Set<Node> expectedNodes =
      ImmutableSet.<Node>of(iaNode, stringNode, a2Node, stringInstanceNode, a2ProviderNode);
  Set<Edge> expectedEdges =
      ImmutableSet.<Edge>of(
          new BindingEdge(
              stringNode.getId(), stringInstanceNode.getId(), BindingEdge.Type.NORMAL),
          new BindingEdge(iaNode.getId(), a2ProviderNode.getId(), BindingEdge.Type.PROVIDER),
          new DependencyEdge(
              a2Node.getId(),
              stringNode.getId(),
              InjectionPoint.forConstructor(A2.class.getConstructor(Provider.class))),
          new DependencyEdge(a2ProviderNode.getId(), a2Node.getId(), null));
  assertEquals("wrong nodes", expectedNodes, grapher.nodes);
  assertEquals("wrong edges", expectedEdges, grapher.edges);
}