What is the name of a nested parameterized type?

Question

The draft spec gives an example of a nested parameterized class Zipper<B> inside a parameterized class Seq<A>. In the sample code the nested type is refered to as Seq<String>.Zipper<Number>. Hence I concluded that the following should work either:
package generics;
public class RawTypes {
private static class Outer<T> {
public class NonstaticInner<T> {}
public static void main(String[] args) {
Outer[] x = new Outer<String>();
Outer<String>.NonstaticInner<String> var = x.new NonstaticInner<String>();
Instead the compiler complains:
incompatible types
found : generics.RawTypes.Outer.NonstaticInner<java.lang.String>
required: generics.RawTypes.Outer<java.lang.String>.NonstaticInner<java.lang.String>
          Outer<String>.NonstaticInner<String> var = x.new NonstaticInner<String>();
When I use the raw outer type the compiler is happy. Like in:
Outer.NonstaticInner<String> var = x.new NonstaticInner<String>();
But that is not what I want say.
Why does this fail to compile? Because the outer class is a nested static class instead of a top-level class? That should not make a difference, I would think. What am I missing?
Angelika

Answer 1

I am quite surprised there is no reaction at your query.
It made me so interested in the spec I downloaded it.
At page 3 I read that no static meber could be parametrized.
I think this makes the behaviour of the compiler correct.No, I don't think so. The spec says:
"The scope of a type parameter is all of the declared class, except any static members or initializers, but including the type parameter section itself."
The spec does not say that static members could not be parameterized. It just says that the type parameter of a generic class cannot be used in any static members of that generic class, be it a static method or a static initializer or the declaration of a static field or a nested static class.
Stuff like this would be prohibited under the quoted wording:
class X<T> {
static T field;
static T getField() { ... }
static { T tmp; ... }
static class Y { T t; }
What I tried is not prohibited by anything in the spec, I believe. I simply defined a generic type (Outer) inside a nongeneric type (RawTypes):
public class RawTypes {
private static class Outer<T> {
public class NonstaticInner<T> {}
The weird thing is that the nested generic type RawTypes.Outer<T> behaves differently from a top-level generic type. Compare the above to the following:
public class Outer<T> {
public class NonstaticInner<T> {}
According to the spec I would refer to the class nested into class Outer<T> as Outer<String>.NonstaticInner<Integer>, for instance. That's basically the example on page 4 of the spec, where they have a Seq<String>.Zipper<Number>.
Why is the behavior entirely different when I want to refer to a class nested into RawTYpes.Outer<T>? Why can't I say RawTypes.Outer<String>.NonstaticInner<Integer>? Why do I have to name it RawTypes.Outer.NonstaticInner<Integer>? That does not make sense to me.
A nested static type is like a top-level type, except that is has a name prefix. Why would that change with the addition of generics to the language?
Outer.NonstaticInner<String> var = x.new
NonstaticInner<String>();
But that is not what I want say.What is it then that you want to say?
Do you want to confine the valid values of var to outer classes parametrized with the
String type? This will lead to problems (I think even with instances) as there is
no specific type for a parametrized class.What error would you expect when a variable
is passed having the correct "inner parameter type" but not the requested outer parameter type?I would expect the same error message that I would get when I assigned a Seq<String>.Zipper<Number> to a Seq<Integer>.Zipper<Number>. No?
Maybe it's just a bug in the prototype compiler, but who can tell if the spec does not say much about nested types what their names would be.
Angelika