@Override public Object resolve(Injectee injectee, ServiceHandle<?> serviceHandle) { if (injectee.getRequiredType() instanceof Class) { TypeLiteral<?> typeLiteral = TypeLiteral.get(injectee.getRequiredType()); Errors errors = new Errors(injectee.getParent()); Key<?> key; try { key = Annotations.getKey(typeLiteral, (Member) injectee.getParent(), injectee.getParent().getDeclaredAnnotations(), errors); } catch (ErrorsException e) { errors.merge(e.getErrors()); throw new ConfigurationException(errors.getMessages()); } return injector.getInstance(key); } throw new IllegalStateException("Can't process injection point: " + injectee.getRequiredType()); }
public void testDuplicateKeys() { try { Guice.createInjector( new AbstractModule() { @Override protected void configure() { bind(DoubleToneCarFactory.class) .toProvider(FactoryProvider.newFactory(DoubleToneCarFactory.class, Maxima.class)); } }); fail(); } catch (CreationException expected) { assertContains( expected.getMessage(), "A binding to " + Color.class.getName() + " annotated with @" + Assisted.class.getName() + "(value=" + Annotations.memberValueString("paint") + ") was already configured at"); } }
/** Returns true if the binding annotation is in the wrong place. */ private static boolean checkForMisplacedBindingAnnotations(Member member, Errors errors) { Annotation misplacedBindingAnnotation = Annotations.findBindingAnnotation( errors, member, ((AnnotatedElement) member).getAnnotations()); if (misplacedBindingAnnotation == null) { return false; } // don't warn about misplaced binding annotations on methods when there's a field with the same // name. In Scala, fields always get accessor methods (that we need to ignore). See bug 242. if (member instanceof Method) { try { if (member.getDeclaringClass().getDeclaredField(member.getName()) != null) { return false; } } catch (NoSuchFieldException ignore) { } } errors.misplacedBindingAnnotation(member, misplacedBindingAnnotation); return true; }
public void testNoImplicitBindingIsCreatedForAnnotatedKeys() { try { Guice.createInjector().getInstance(Key.get(I.class, Names.named("i"))); fail(); } catch (ConfigurationException expected) { Asserts.assertContains( expected.getMessage(), "1) No implementation for " + I.class.getName(), "annotated with @" + Named.class.getName() + "(value=" + Annotations.memberValueString("i") + ") was bound.", "while locating " + I.class.getName(), " annotated with @" + Named.class.getName() + "(value=" + Annotations.memberValueString("i") + ")"); } }
private static void assertDuplicateBinding(Module a, Module b, boolean fails) { try { Guice.createInjector(a, b); if (fails) { fail("should have thrown CreationException"); } } catch (CreationException e) { if (fails) { assertContains( e.getMessage(), "A binding to java.lang.String annotated with @com.google.inject.name.Named(value=" + Annotations.memberValueString("foo") + ") was already configured"); } else { throw e; } } }
/** * Returns true if the binding annotation is in the wrong place. */ private static boolean checkForMisplacedBindingAnnotations(Member member, Errors errors) { Annotation misplacedBindingAnnotation = Annotations.findBindingAnnotation( errors, member, ((AnnotatedElement) member).getAnnotations()); if (misplacedBindingAnnotation == null) { return false; } // don't warn about misplaced binding annotations on methods when there's a field with the same // name. In Scala, fields always get accessor methods (that we need to ignore). See bug 242. if (member instanceof Method) { try { if (member.getDeclaringClass().getDeclaredField(member.getName()) != null) { return false; } } catch (NoSuchFieldException ignore) { } } errors.misplacedBindingAnnotation(member, misplacedBindingAnnotation); return true; }
@SuppressWarnings("PMD.UnusedPrivateMethod") private static void applyScopeAnnotation(final ClassPool classPool, final AnnotationsAttribute annotations, final AnnotatedElement source, final Class<? extends java.lang.annotation.Annotation> scope) throws Exception { if (scope != null) { Preconditions.checkState(Annotations.isScopeAnnotation(scope), "Provided annotation %s is not scope annotation", scope.getSimpleName()); for (java.lang.annotation.Annotation ann : source.getAnnotations()) { Preconditions.checkArgument(!(ann instanceof ScopeAnnotation), "Duplicate scope definition: scope is specified as %s and also defined " + "in @ScopeAnnotation.", scope.getSimpleName()); } annotations.addAnnotation(new Annotation(annotations.getConstPool(), classPool.get(scope.getName()))); } }
@Override protected void configure() { final Errors errors = new Errors(testClass); for (FrameworkField field : fields) { try { final Field f = field.getField(); final Key key = Annotations.getKey(TypeLiteral.get(f.getGenericType()), f, field.getAnnotations(), errors); bindMock(key, f.getType(), "Automock[" + field.getName() + "] " + key); } catch (ErrorsException e) { // Add it to the error list and hold them all until the end errors.merge(e.getErrors()); } } errors.throwConfigurationExceptionIfErrorsExist(); }
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; }
@Override protected void doStart() throws Exception { // Please do not remove // This kludge is about ensuring these annotations are parsed to prevent // a deadlock Annotations.isRetainedAtRuntime(Assisted.class); Annotations.isRetainedAtRuntime(AssistedInject.class); Annotations.isRetainedAtRuntime(BindingAnnotation.class); // End kludge privatePluginService = (PrivatePluginService) AbstractPluginService.get(); getManager().getRegistry().registerListener(this); setupBeanLocators(); }
private static Object makeProxyGuice ( String method, Object iter, Class<?>... types ) throws Exception { Method meth = Annotations.class.getDeclaredMethod("generateAnnotationImpl", Class.class); //$NON-NLS-1$ meth.setAccessible(true); Object o = meth.invoke(null, Override.class); InvocationHandler inv = Proxy.getInvocationHandler(o); Map<String, Object> values = new HashMap<>(); values.put(method, iter); Reflections.setFieldValue(inv, "val$members", values); return Proxy.newProxyInstance(MockProxies.class.getClassLoader(), types, inv); }
/** * Gets the strategy for an annotation. */ static AnnotationStrategy strategyFor(Annotation annotation) { checkNotNull(annotation, "annotation"); Class<? extends Annotation> annotationType = annotation .annotationType(); ensureRetainedAtRuntime(annotationType); ensureIsBindingAnnotation(annotationType); if (Annotations.isMarker(annotationType)) { return new AnnotationTypeStrategy(annotationType, annotation); } return new AnnotationInstanceStrategy( Annotations.canonicalizeIfNamed(annotation)); }
/** * Gets the strategy for an annotation type. */ static AnnotationStrategy strategyFor( Class<? extends Annotation> annotationType) { annotationType = Annotations.canonicalizeIfNamed(annotationType); if (isAllDefaultMethods(annotationType)) { return strategyFor(generateAnnotation(annotationType)); } checkNotNull(annotationType, "annotation type"); ensureRetainedAtRuntime(annotationType); ensureIsBindingAnnotation(annotationType); return new AnnotationTypeStrategy(annotationType, null); }
Providers(@Nullable T providersInstance, Class<T> providerClass) { this.providersInstance = providersInstance; this.providersClass = providerClass; this.source = StackTraceElements.forType(providersClass); this.type = TypeToken.of(providersClass); this.errors = new Errors(source); this.scopeAnnotation = Annotations.findScopeAnnotation(errors, providersClass); this.providers = introspectProviders(); }
private EventualProvider<?> providerFor(Invokable<T, ?> method, Errors methodErrors) { Annotation[] annotations = method.getAnnotations(); verifyMethodAccessibility(methodErrors, method, source); @Nullable Annotation bindingAnnotation = Annotations.findBindingAnnotation(methodErrors, method, annotations); verifyAbsenseOfScopeAnnotation(methodErrors, annotations, source); List<Dependency<ListenableFuture<?>>> dependencies = Lists.newArrayListWithCapacity(method.getParameters().size()); for (Parameter parameter : method.getParameters()) { dependencies.add(extractDependency(methodErrors, parameter)); } Key<ListenableFuture<?>> bindingKey; boolean exposedBinding = method.isAnnotationPresent(Exposed.class); if (isVoid(method)) { bindingKey = futureKey(TypeToken.of(Boolean.class), new BlackholedAnnotation()); exposedBinding = false; } else { bindingKey = futureKey(method.getReturnType(), bindingAnnotation); } return new EventualProvider<>( method, exposedBinding, dependencies, bindingKey, scopeAnnotation, source); }
private void verifyAbsenseOfScopeAnnotation(Errors methodErrors, Annotation[] annotations, Object source) { @Nullable Class<? extends Annotation> methodScopeAnnotation = Annotations.findScopeAnnotation(methodErrors, annotations); if (methodScopeAnnotation != null) { methodErrors.addMessage( "Misplaced scope annotation @%s on method @%s %s." + "\n\tScope annotation will only be inherited from enclosing class %s", methodScopeAnnotation.getSimpleName(), Eventually.Provides.class.getSimpleName(), source, providersClass.getSimpleName()); } }
Dependency<ListenableFuture<?>> extractDependency(Errors methodErrors, Parameter parameter) { @Nullable Annotation bindingAnnotation = Annotations.findBindingAnnotation( methodErrors, parameter.getDeclaringInvokable(), parameter.getAnnotations()); return Dependency.get(futureKey( parameter.getType(), bindingAnnotation)); }
private LinkedBindingBuilder<?> verifyBindingAnnotations( Field field, AnnotatedBindingBuilder<?> annotatedBinder) { LinkedBindingBuilder<?> binderRet = annotatedBinder; for (Annotation annotation : field.getAnnotations()) { Class<? extends Annotation> annotationType = annotation.annotationType(); if (Annotations.isBindingAnnotation(annotationType)) { // not returning here ensures that annotatedWith will be called multiple times if this field // has multiple BindingAnnotations, relying on the binder to throw an error in this case. binderRet = annotatedBinder.annotatedWith(annotation); } } return binderRet; }
/** Returns true if the given class has a scope annotation. */ private static boolean hasScope(Class<? extends Interceptor> interceptorClass) { for (Annotation annotation : interceptorClass.getAnnotations()) { if (Annotations.isScopeAnnotation(annotation.annotationType())) { return true; } } return false; }
/** * Returns the unique binding annotation from the specified list, or {@code null} if there are * none. * * @throws IllegalStateException if multiple binding annotations exist. */ private Annotation getBindingAnnotation(Annotation[] annotations) { Annotation bindingAnnotation = null; for (Annotation annotation : annotations) { if (Annotations.isBindingAnnotation(annotation.annotationType())) { checkArgument( bindingAnnotation == null, "Parameter has multiple binding annotations: %s and %s", bindingAnnotation, annotation); bindingAnnotation = annotation; } } return bindingAnnotation; }
@Override public String toString() { return "@" + Assisted.class.getName() + "(value=" + Annotations.memberValueString("") + ")"; }
@SuppressWarnings("unchecked") // safe because it's a constructor of the typeLiteral static <T> Constructor<? extends T> findThrowingConstructor( TypeLiteral<? extends T> typeLiteral, Binder binder) { Class<?> rawType = typeLiteral.getRawType(); Errors errors = new Errors(rawType); Constructor<?> cxtor = null; for (Constructor<?> constructor : rawType.getDeclaredConstructors()) { if (constructor.isAnnotationPresent(ThrowingInject.class)) { if (cxtor != null) { errors.addMessage( "%s has more than one constructor annotated with @ThrowingInject. " + CONSTRUCTOR_RULES, rawType); } cxtor = constructor; Annotation misplacedBindingAnnotation = Annotations.findBindingAnnotation( errors, cxtor, ((AnnotatedElement) cxtor).getAnnotations()); if (misplacedBindingAnnotation != null) { errors.misplacedBindingAnnotation(cxtor, misplacedBindingAnnotation); } } } if (cxtor == null) { errors.addMessage( "Could not find a suitable constructor in %s. " + CONSTRUCTOR_RULES, rawType); } for (Message msg : errors.getMessages()) { binder.addError(msg); } return (Constructor<? extends T>) cxtor; }
/** Gets the strategy for an annotation. */ static AnnotationStrategy strategyFor(Annotation annotation) { checkNotNull(annotation, "annotation"); Class<? extends Annotation> annotationType = annotation.annotationType(); ensureRetainedAtRuntime(annotationType); ensureIsBindingAnnotation(annotationType); if (Annotations.isMarker(annotationType)) { return new AnnotationTypeStrategy(annotationType, annotation); } return new AnnotationInstanceStrategy(Annotations.canonicalizeIfNamed(annotation)); }
/** Gets the strategy for an annotation type. */ static AnnotationStrategy strategyFor(Class<? extends Annotation> annotationType) { annotationType = Annotations.canonicalizeIfNamed(annotationType); if (isAllDefaultMethods(annotationType)) { return strategyFor(generateAnnotation(annotationType)); } checkNotNull(annotationType, "annotation type"); ensureRetainedAtRuntime(annotationType); ensureIsBindingAnnotation(annotationType); return new AnnotationTypeStrategy(annotationType, null); }
/** * Ensure that when we've got errors in different private modules, Guice presents all errors in a * unified message. */ public void testMessagesFromPrivateModulesAreNicelyIntegrated() { try { Guice.createInjector( new PrivateModule() { @Override public void configure() { bind(C.class); } }, new PrivateModule() { @Override public void configure() { bind(AB.class); } }); fail(); } catch (CreationException expected) { assertContains( expected.getMessage(), "1) No implementation for " + C.class.getName() + " was bound.", "at " + getClass().getName(), getDeclaringSourcePart(getClass()), "2) No implementation for " + String.class.getName(), "Named(value=" + Annotations.memberValueString("a") + ") was bound.", "for field at " + AB.class.getName() + ".a(PrivateModuleTest.java:", "3) No implementation for " + String.class.getName(), "Named(value=" + Annotations.memberValueString("b") + ") was bound.", "for field at " + AB.class.getName() + ".b(PrivateModuleTest.java:", "3 errors"); } }
public void testMissingAnnotationOneChoice() { Injector injector = Guice.createInjector(new AbstractModule() { @SuppressWarnings("unchecked") @Override public void configure() { bind(Bacon.class).annotatedWith(named("Turkey")).to(TurkeyBacon.class); } }); try { // turkey typo (should be Upper case)... injector.getInstance(Key.get(Bacon.class, named("turkey"))); fail(); } catch (ConfigurationException e) { String msg = e.getMessage(); assertContains(msg, "Guice configuration errors:"); assertContains( msg, "1) No implementation for com.google.inject.BindingTest$Bacon" + " annotated with" + " @com.google.inject.name.Named(value=" + Annotations.memberValueString("turkey") + ") was bound.", "Did you mean?", "* com.google.inject.BindingTest$Bacon annotated with" + " @com.google.inject.name.Named(value=" + Annotations.memberValueString("Turkey") + ")", "while locating com.google.inject.BindingTest$Bacon annotated with" + " @com.google.inject.name.Named(value=" + Annotations.memberValueString("turkey") + ")"); } }
private static void assertMissingBindingErrorMessageUsesType(Class<?> clientType) { try { Guice.createInjector().getInstance(clientType); fail("should have thrown ConfigurationException"); } catch (ConfigurationException e) { assertContains( e.getMessage(), "No implementation for java.lang.String annotated with " + "@com.google.inject.name.Named(value=" + Annotations.memberValueString("foo") + ") was bound."); } }
@Override public String toString() { return "@" + javax.inject.Named.class.getName() + "(value=" + Annotations.memberValueString(value) + ")"; }
@Override public String toString() { return "@" + com.google.inject.name.Named.class.getName() + "(value=" + Annotations.memberValueString(value) + ")"; }
public void testGettingAnnotatedMembersInjector() { Injector injector = Guice.createInjector(); try { injector.getInstance(new Key<MembersInjector<String>>(Names.named("foo")) {}); fail(); } catch (ConfigurationException expected) { assertContains( expected.getMessage(), "1) No implementation for com.google.inject.MembersInjector<java.lang.String> " + "annotated with @com.google.inject.name.Named(value=" + Annotations.memberValueString("foo") + ") was bound."); } }
/** * Returns true if the given class has a scope annotation. */ private static boolean hasScope(Class<? extends Interceptor> interceptorClass) { for (Annotation annotation : interceptorClass.getAnnotations()) { if (Annotations.isScopeAnnotation(annotation.annotationType())) { return true; } } return false; }