Bug 289490

Description Stephan Herrmann 2009-09-15 12:14:00 EDT

(follow up from bug 284131 comment 8)

Given two projects: Src and Bin.
Src contains this class:

public class Test {
	class MyRunnable<T> {
		/** Doc of my uber run method. */
		public void run(T arg) { } 
	}
	void enclosingMethod(final int i) {
		new MyRunnable<Integer>() {
			/** The run implementation. */
			public void run(Integer j) {
				System.out.println(j);
			}
		}.run(3);
	}
}

Project Bin only contains a jar file compiled from p1.Test (incl. sources),
jar is on Bin's build path.

Excercise is to inspect the type hierarchy for the anonymous type
within enclosingMethod (selecting type name in the allocation expr
and hitting F4).

Two "features" appear/disappear according to some internal state:

(I) Hierarchy may or may not show duplicate types "MyRunnable<T>". To enable
this "feature" open both files (src and bin) in editors and select the binary
version and hit F4. To disable, close project "Src" and re-create hierarchy.
Actually, this feature is not related to anonymous types, works for any type.
What's confusing: if the src version is not open in an editor, but project
is open, it will not appear in the hierarchy.

(II) Hiearchy may or may not show the anonymous type.
Initially the anonymous type is not shown (sometimes?), after requesting 
the type hierarchy for method run() of the anonymous type, hierarchy will
"know" about the anonymous type and also show it in subsequent requests.
Unfortunately, after the anonymous type has been shown once, I see no
way to make it disappear again (incl. deleting indexes and wb restart),
so this may be difficult to track down. Right now, e.g., I get a missing
anonymous type only if Test is in the default package (!).

It seems that the anonymous type is never the focus type of the hierarchy.
This corresponds to the behaviour that the type name is interpreted
as a type reference, not a declaration (F2 shows super type doc, F3 jumps
to super type), so selecting the anonymous type is only possible by
selecting one of its methods. Is this by design?

Even with duplicate super types "MyRunnable<T>" the anonymous type will
show at most once.

With only the Src project open, the anonymous type is always there.