Add support for Nullable as a TYPE_USE annotation

[tbroyer]

I wanted to switch from JSR305 to Checker Framework @Nullable, but it breaks my @Nullable injection points:

1) null returned by binding at […]
 but the 1st parameter of […].<init>([…]) is not @Nullable

Apparently, this is because Guice only looks at field and parameter annotations, not TYPE_USE annotations:

guice/core/src/com/google/inject/spi/InjectionPoint.java

Lines 117 to 119 in eface21

	Annotation[] parameterAnnotations = paramterAnnotations[index];
	Key<?> key = Annotations.getKey(parameterType, member, parameterAnnotations, errors);
	dependencies.add(newDependency(key, Nullability.allowsNull(parameterAnnotations), index));

Note: I couldn't use the Java 7-compatible annotations from the Checker Framework either because it's named @NullableDecl, and Guice only looks at annotations named @Nullable.

[tbroyer]

Possible workaround: in our case, I could easily switch to OptionalBinder and Optional<T> instead of @Nullable T.

[ronshapiro]

FWIW, we decided (both Guice and Dagger) to ignore type annotations for qualifiers at least for the time being because of the complications that they may introduce into the key/type system that weren't previously considered.

This may be entirely different, as I'm not familiar with this part of Guice, but there's always the consideration of something like this:

class Foo<T> {
  @Inject Foo(T t) {}
}

class Bar {
  @Inject Bar(Foo<@Nullable String> fooOfNullableString) {} 
}

[nresare]

To clarify what I believe is happening here, the annotations that describe annotations and the reflection API to get information about annotations was extended in jdk8. Annotations such as @Nullable can now have a @Target({TYPE_USE}) and this does indeed make sense to use for something like @Nullable. This is what for example he checkerframework Nullable uses. To extract such annotation from a constructor, one need to use constructor.getAnnotatedParameterTypes()...getAnnotations() which was introduced in java8.

[cpovirk]

There are a lot of things that "Guice supports @Nullable type annotations" could mean, but 1a410a8 accomplished the main one. I assume there hasn't been a release yet, though.

[cpovirk]

It looks to me like 5.0.0 (though use 5.0.1 instead), released earlier this year, contains the change that lets you write @Nullable Foo foo for type-use annotations as well as for declaration annotations.

As discussed above, Guice could theoretically do more with type-use annotations, but this at least makes them not worse than declaration annotations. Possibly that's enough to close this issue.

Anyone who migrates from declaration annotations to type-use annotations may need to move some annotations along the way:

• @Nullable Foo[] foo -> Foo @Nullable [] foo
• @Nullable Foo.Bar bar -> Foo.@Nullable Bar bar

(That's just how type-use-annotation syntax works.)

(I don't see mention of this in the release notes. Maybe it should be added?)

[sameb]

This was fixed in 1a410a8.