Why can't I have a two-level-deep inner class with the same name as its containing class?

Question

Today, some other developer found an XML schema with some interesting nesting, which JAXB compiled into a structure like this:

public class Choices
{
    public static class Choice
    {
        public static class Choice
        {
        }
    }
}

If you try to compile this, the Java compiler says,

class Choices.Choice is already defined in class Choices

with of course, the underline on the innermost class Choice declaration.

But I say, class Choices.Choice is not what it was trying to declare. Rather, it was trying to declare Choices.Choice.Choice, which would be a different class.

Interestingly, this is fine:

public class OuterClass
{
    public static class Inner1
    {
        public static class Inner2
        {
        }
    }

    public static class Inner2
    {
        public static class Inner1
        {
        }
    }
}

But this is banned:

public class OuterClass
{
    public static class Inner1
    {
        public static class Inner2
        {
            public static class Inner1
            {
            }
        }
    }
}

So I guess the rule is that the name of a class can't be the same as a containing class at any level. Obviously the fix here is already known- get JAXB not to generate invalid code.

But my question is, why is this restriction even present? What is the Java compiler trying to avoid by not letting us create an inner class with the same name as a containing class?

Answer 1

Java lets you refer to an outer class without fully specifying its name, like this:

public static class Inner1
{
    public static class Inner2
    {
        public static class Inner3
        {
            public void demo() {
                Class<Inner2> c = Inner2.class; // This is allowed
            }
        }
    }
}

Had nesting of classes allowed the use of identical names at any level of hierarchy, referencing by unqualified name would have been impossible. It is this ability that the Java compiler is trying to preserve by prohibiting nested declarations to collide with names of their outer classes.