[type-annos-observers] Should JSR308 forbid type annotations on uses of a type parameter ?

[Alex Buckley]

Werner, thanks for this explanation.

Perhaps if the idea of a different model for annotations on type 
parameters and type variables had been raised 18 months ago, the EG 
could have considered it. But right now, JSR 308 is in the "endgame". 
The JDK 8 Developer Preview is out and we just hit the "All Tests Run" 
milestone today [1]. Early next month, all interfaces will be frozen and 
the SE JSRs will start Public Review [2]. What would help the most is to 
review the detailed wording of the Java Language Spec and JVM Spec draft 
I sent out last month.

Alex

[1] http://openjdk.java.net/projects/jdk8/milestones
[2] http://openjdk.java.net/projects/jdk8/spec/.

On 9/12/2013 2:27 AM, Werner Dietl wrote:
> Hi Srikanth,
>
> For the use in type systems, having the distinction between type parameter
> declarations and type variable uses is necessary.
>
> The Checker Framework manual dedicates a section discussing this
> interaction:
> http://types.cs.washington.edu/checker-framework/current/checkers-manual.html#generics
>
> In brief,  one can imagine:
>
> class C<@TA T extends @TB Upper> {
>      T field1;
>      @TC T field2;
> }
>
> Note that @TA can have @Target meta-annotation TYPE_PARAMETER - which is
> subsumed in the more general TYPE_USE.
>
> In the Checker Framework,  we interpret @TA as an annotation on the
> implicit lower bound of type variable T.
> @TB is an annotation on the upper bound of T.
>
> Fields field1 and field2 have different types.
> The type of field1 is the normal use of the type variable and behaves like
> a type variable in Java.
> The type of field2 gives a more specific type annotation,  @TC, that should
> override any annotations from T.
>
> As a concrete example,  let's consider a Nullness type system with
> annotations @Nullable and @NonNull, where a @NonNull reference is a subtype
> of a @Nullable reference.
>
> We can imagine a class:
>
> class Box<@NonNull T extends @Nullable Object> {
>    T f1;
>    @Nullable T f2;
>
>    void foo() {
>      f1 = null; // error
>      f2 = null; // valid
>    }
> }
>
> The lower bound of T is @NonNull and the upper bound is @Nullable - any
> instantiation is allowed.
>
> The first assignment must be forbidden: the concrete instantiation of Box
> might be "Box<@NonNull String>" ; allowing the assignment of the null value
> into field f1 would be unsound.
> However,  the type of field f2 declares that null is always a valid value
> and therefore the assignment to f2 is valid.
>
> This is the interpretation that we are using in the Checker Framework.
> However,  making the distinction between type parameter declarations and
> type variable uses is a general one and allowing different type annotations
> on them seems generally useful.
>
> Does this explanation help?
> cu, WMD.
> On Sep 11, 2013 10:39 PM, "Srikanth S Adayapalam" <
> srikanth_sankaran at in.ibm.com> wrote:
>
>> Hello !
>>
>> I am trying to understand if there are valid scenarios where type
>> annotating the use of a type
>> variable actually makes sense. The following program compiles fine with
>> both eclipse and
>> javac 8b100:
>>
>> import java.lang.annotation.ElementType;
>> import java.lang.annotation.Target;
>>
>> @Target(ElementType.TYPE_USE)
>> @interface TA {
>> }
>> @Target(ElementType.TYPE_USE)
>> @interface TB {
>> }
>>
>> public abstract class X<@TA T> {
>>
>>                   @TB T t;
>> }
>>
>> Studying this test case, since both occurrence of T would denote the
>> same type instantiation, does it make sense to think of "only @TA
>> annotated T" and "only @TB annotated T" ?
>>
>> Shouldn't the language insist that they be consolidated and presented all
>> at the declaration site ?
>>
>> Have I overlooked any valid scenarios where this would actually make sense
>> ?
>>
>> Thanks!
>> Srikanth
>>