Attachment #77388 for bug #189158




	 * LY<TT;>;
	 */
	public char[] genericTypeSignature() {
		if (this.genericTypeSignature == null) {
			if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) {
		    	this.genericTypeSignature = genericType().signature();
			} else {
			    StringBuffer sig = new StringBuffer(10);
			    if (this.isMemberType()) {
			    	ReferenceBinding enclosing = enclosingType();
			    	boolean hasParameterizedEnclosing = enclosing.isParameterizedType();
					char[] typeSig = hasParameterizedEnclosing ? enclosing.genericTypeSignature() : enclosing.signature();
					sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
			    	if (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
//			    	if (this.arguments != null || (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)) {
			    		sig.append('.');
			    	} else {
			    		sig.append('$');
			    	}
			    	sig.append(this.sourceName());
			    } else {
			    	char[] typeSig = genericType().signature();
					sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
		    	}
				sig.append(';');
				int sigLength = sig.length();
				this.genericTypeSignature = new char[sigLength];
				sig.getChars(0, sigLength, this.genericTypeSignature, 0);						
			} else {
			     this.genericTypeSignature = genericType().signature(); // erasure
			}
		}
		return this.genericTypeSignature;
	}		
	
    public boolean isEquivalentTo(TypeBinding otherType) {




	 * LY<TT;>;
	 */
	public char[] genericTypeSignature() {
		if (this.genericTypeSignature == null) {
			if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) {
		    	this.genericTypeSignature = this.type.signature();
			    char[] typeSig = this.enclosingType().genericTypeSignature();
			    for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon
			    sig.append('.').append(this.sourceName());
			} else {
			    StringBuffer sig = new StringBuffer(10);
			    if (this.isMemberType()) {
			    	ReferenceBinding enclosing = enclosingType();
			    	boolean hasParameterizedEnclosing = enclosing.isParameterizedType();
					char[] typeSig = hasParameterizedEnclosing ? enclosing.genericTypeSignature() : enclosing.signature();
					sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
			    	if (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
//			    	if (this.arguments != null || (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)) {
			    		sig.append('.');
			    	} else {
			    		sig.append('$');
			    	}
			    	sig.append(this.sourceName());
			    } else {
			    	char[] typeSig = this.type.signature();
					sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
		    	}
				if (this.arguments != null) {
				    sig.append('<');
				    for (int i = 0, length = this.arguments.length; i < length; i++) {
				        sig.append(this.arguments[i].genericTypeSignature());
				    }
				    sig.append('>');
				}
				sig.append(';');
				int sigLength = sig.length();
				this.genericTypeSignature = new char[sigLength];
				sig.getChars(0, sigLength, this.genericTypeSignature, 0);						
			}
		}
		return this.genericTypeSignature;
	}
	
	/**




		false, // do not flush output
		null);		
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158
public void test1150() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.lang.ref.Reference;\n"+
			"public class X<T> {\n" + 
			"	static class Rather {\n" + 
			"		static class Deeply {\n" + 
			"			static class Inside {\n" + 
			"			}\n" + 
			"		}\n" + 
			"	}\n" + 
			"	Reference<X.Rather.Deeply> x;\n" + 
			"	Reference<X.Rather> y;	\n" + 
			"	Reference<X.Rather.Deeply.Inside> z;	\n" + 
			"\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		System.out.print(X.class.getDeclaredField(\"x\").getGenericType());\n" + 
			"		System.out.print(\"##\");\n" + 
			"		System.out.print(X.class.getDeclaredField(\"y\").getGenericType());\n" + 
			"		System.out.print(\"##\");\n" + 
			"		System.out.print(X.class.getDeclaredField(\"z\").getGenericType());\n" + 
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		"java.lang.ref.Reference<X$Rather$Deeply>##java.lang.ref.Reference<X$Rather>##java.lang.ref.Reference<X$Rather$Deeply$Inside>"
	);
	String expectedOutput = 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX$Rather$Deeply;>;\n" + 
		"  java.lang.ref.Reference x;\n" + 
		"  \n" + 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX$Rather;>;\n" + 
		"  java.lang.ref.Reference y;\n" + 
		"  \n" + 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX$Rather$Deeply$Inside;>;\n" + 
		"  java.lang.ref.Reference z;\n";

	try {
		File f = new File(OUTPUT_DIR + File.separator + "X.class");
		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		int index = result.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {
			System.out.println(Util.displayString(result, 3));
		}
		if (index == -1) {
			assertEquals("Wrong contents", expectedOutput, result);
		}
	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		assertTrue(false);
	} catch (IOException e) {
		assertTrue(false);
	}			
	
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
public void test1151() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.lang.ref.Reference;\n"+
			"public class X<T> {\n" + 
			"	class Other<U> {\n" + 
			"		class Deeply {\n" + 
			"			class Inside<V> {\n" + 
			"			}			\n" + 
			"		}\n" + 
			"	}\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply> t;\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" + 
			"\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" + 
			"		//System.out.print(\"##\");\n" + 
			"		//System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		//"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>##java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply$Inside<java.lang.Number>>"
		"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>"
	);
	String expectedOutput = 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply;>;\n" + 
		"  java.lang.ref.Reference t;\n" + 
		"  \n" + 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply.Inside<Ljava/lang/Number;>;>;\n" + 
		"  java.lang.ref.Reference u;\n";

	try {
		File f = new File(OUTPUT_DIR + File.separator + "X.class");
		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		int index = result.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {
			System.out.println(Util.displayString(result, 3));
		}
		if (index == -1) {
			assertEquals("Wrong contents", expectedOutput, result);
		}
	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		assertTrue(false);
	} catch (IOException e) {
		assertTrue(false);
	}			
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
public void test1152() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.lang.ref.Reference;\n"+
			"public class X<T> {\n" + 
			"	class Other<U> {\n" + 
			"		class Deeply {\n" + 
			"			class Inside<V> {\n" + 
			"			}			\n" + 
			"		}\n" + 
			"	}\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply.Inside> u;\n" + 
			"\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + 
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	Reference<X<String>.Other<Thread>.Deeply.Inside> u;\n" + 
		"	          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The member type X<String>.Other<Thread>.Deeply.Inside must be parameterized, since it is qualified with a parameterized type\n" + 
		"----------\n"	);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
public void test1153() {
	// check proper decoding of binary signatures, by compiling against generated binary
	this.runConformTest(
		new String[] {
			"p/X.java",
			"package p;\n" +
			"import java.lang.ref.Reference;\n" + 
			"public class X<T> {\n" + 
			"	public static class Rather {\n" + 
			"		public static class Deeply {\n" + 
			"			public static class Inside {\n" + 
			"			}\n" + 
			"		}\n" + 
			"	}\n" + 
			"	public class Other<U> {\n" + 
			"		public class Deeply {\n" + 
			"			public class Inside<V> {\n" + 
			"			}			\n" + 
			"		}\n" + 
			"	}\n" + 
			"	public Reference<X.Rather.Deeply> x;\n" + 
			"	public Reference<X.Rather> y;	\n" + 
			"	public Reference<X.Rather.Deeply.Inside> z;	\n" + 
			"	public Reference<X<String>.Other<Thread>.Deeply> t;\n" + 
			"	public Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" + 
			"}\n",
		},
		""
	);
	this.runConformTest(
		new String[] {
			"Y.java",
			"import java.lang.ref.Reference;\n" + 
			"import p.X;\n" +
			"public class Y {\n" + 
			"	Reference<X.Rather.Deeply> x;\n" + 
			"	Reference<X.Rather> y;	\n" + 
			"	Reference<X.Rather.Deeply.Inside> z;	\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply> t;\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" + 
			"	Y(X someX) {\n" + 
			"		this.x = someX.x;\n" + 
			"		this. y = someX.y;	\n" + 
			"		this.z = someX.z;	\n" + 
			"		this.t = someX.t;\n" + 
			"		this.u = someX.u;		\n" + 
			"	}\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		System.out.print(Y.class.getDeclaredField(\"x\").getGenericType());\n" + 
			"		System.out.print(\"##\");\n" + 
			"		System.out.print(Y.class.getDeclaredField(\"y\").getGenericType());\n" + 
			"		System.out.print(\"##\");\n" + 
			"		System.out.print(Y.class.getDeclaredField(\"z\").getGenericType());\n" + 
			"		System.out.print(\"##\");\n" + 
			"		System.out.print(Y.class.getDeclaredField(\"t\").getGenericType());\n" + 
			"		//System.out.print(\"##\");\n" + 
			"		//System.out.print(Y.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		"java.lang.ref.Reference<p.X$Rather$Deeply>##java.lang.ref.Reference<p.X$Rather>##java.lang.ref.Reference<p.X$Rather$Deeply$Inside>##java.lang.ref.Reference<p.X<java.lang.String>.Other<java.lang.Thread>.Deeply>",
		null,
		false, // do not flush output
		null);		
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
public void test1154() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.lang.ref.Reference;\n" + 
			"public class X {\n" + 
			"	class Other<U> {\n" + 
			"		class Deeply {\n" + 
			"			class Deeper {\n" + 
			"				class Inside<V> {\n" + 
			"				}			\n" + 
			"			}\n" + 
			"		}\n" + 
			"	}\n" + 
			"	Reference<X.Other<Thread>.Deeply> t;\n" + 
			"	Reference<X.Other<Thread>.Deeply.Deeper.Inside<Number>> u;\n" + 
			"\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		//System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" +  // TODO disabled due to bug in libs (unable to re-read the generated signature)
			"		//System.out.print(\"##\");\n" + 
			"		//System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		"");
	
	String expectedOutput = 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX$Other<Ljava/lang/Thread;>.Deeply;>;\n" + 
		"  java.lang.ref.Reference t;\n" + 
		"  \n" + 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX$Other<Ljava/lang/Thread;>.Deeply.Deeper.Inside<Ljava/lang/Number;>;>;\n" + 
		"  java.lang.ref.Reference u;\n";

	try {
		File f = new File(OUTPUT_DIR + File.separator + "X.class");
		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		int index = result.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {
			System.out.println(Util.displayString(result, 3));
		}
		if (index == -1) {
			assertEquals("Wrong contents", expectedOutput, result);
		}
	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		assertTrue(false);
	} catch (IOException e) {
		assertTrue(false);
	}	
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
public void test1155() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.lang.ref.Reference;\n" + 
			"public class X<T> {\n" + 
			"	class Other<U> {\n" + 
			"		class Deeply {\n" + 
			"			class Deeper {\n" + 
			"				class Inside<V> {\n" + 
			"				}			\n" + 
			"			}\n" + 
			"		}\n" + 
			"	}\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply> t;\n" + 
			"	Reference<X<String>.Other<Thread>.Deeply.Deeper.Inside<Number>> u;\n" + 
			"\n" + 
			"	public static void main(String[] args) throws Exception {\n" + 
			"		System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" + 
			"		//System.out.print(\"##\");\n" + 
			"		//System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
			"		System.out.println();\n" + 
			"	}\n" + 
			"}\n"
		},
		"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>"	);
	
	String expectedOutput = 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply;>;\n" + 
		"  java.lang.ref.Reference t;\n" + 
		"  \n" + 
		"  // Field descriptor #6 Ljava/lang/ref/Reference;\n" + 
		"  // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply.Deeper.Inside<Ljava/lang/Number;>;>;\n" + 
		"  java.lang.ref.Reference u;\n";

	try {
		File f = new File(OUTPUT_DIR + File.separator + "X.class");
		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		int index = result.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {
			System.out.println(Util.displayString(result, 3));
		}
		if (index == -1) {
			assertEquals("Wrong contents", expectedOutput, result);
		}
	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		assertTrue(false);
	} catch (IOException e) {
		assertTrue(false);
	}	
}
}

Return to bug 189158

Lines 75-95 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java (-12 / +25 lines)
75	* LY<TT;>;	75	* LY<TT;>;
76	*/	76	*/
77	public char[] genericTypeSignature() {	77	public char[] genericTypeSignature() {
78		78	if (this.genericTypeSignature == null) {
79	if (this.genericTypeSignature == null) {	79	if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) {
80	StringBuffer sig = new StringBuffer(10);	80	this.genericTypeSignature = genericType().signature();
81	if (this.isMemberType() && this.enclosingType().isParameterizedType()) {	81	} else {
82	char[] typeSig = this.enclosingType().genericTypeSignature();	82	StringBuffer sig = new StringBuffer(10);
83	for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon	83	if (this.isMemberType()) {
84	sig.append('.').append(this.sourceName()).append(';');	84	ReferenceBinding enclosing = enclosingType();
		85	boolean hasParameterizedEnclosing = enclosing.isParameterizedType();
		86	char[] typeSig = hasParameterizedEnclosing ? enclosing.genericTypeSignature() : enclosing.signature();
		87	sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
		88	if (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
		89	// if (this.arguments != null \|\| (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)) {
		90	sig.append('.');
		91	} else {
		92	sig.append('$');
		93	}
		94	sig.append(this.sourceName());
		95	} else {
		96	char[] typeSig = genericType().signature();
		97	sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
		98	}
		99	sig.append(';');
85	int sigLength = sig.length();	100	int sigLength = sig.length();
86	this.genericTypeSignature = new char[sigLength];	101	this.genericTypeSignature = new char[sigLength];
87	sig.getChars(0, sigLength, this.genericTypeSignature, 0);	102	sig.getChars(0, sigLength, this.genericTypeSignature, 0);
88	} else {
89	this.genericTypeSignature = genericType().signature(); // erasure
90	}	103	}
91	}	104	}
92	return this.genericTypeSignature;	105	return this.genericTypeSignature;
93	}	106	}
94		107
95	public boolean isEquivalentTo(TypeBinding otherType) {	108	public boolean isEquivalentTo(TypeBinding otherType) {

Lines 362-390 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-22 / +34 lines)
362	* LY<TT;>;	362	* LY<TT;>;
363	*/	363	*/
364	public char[] genericTypeSignature() {	364	public char[] genericTypeSignature() {
365	if (this.genericTypeSignature == null) {	365	if (this.genericTypeSignature == null) {
366	StringBuffer sig = new StringBuffer(10);	366	if ((this.modifiers & ExtraCompilerModifiers.AccGenericSignature) == 0) {
367	if (this.isMemberType() && this.enclosingType().isParameterizedType()) {	367	this.genericTypeSignature = this.type.signature();
368	char[] typeSig = this.enclosingType().genericTypeSignature();
369	for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon
370	sig.append('.').append(this.sourceName());
371	} else {	368	} else {
372	char[] typeSig = this.type.signature();	369	StringBuffer sig = new StringBuffer(10);
373	for (int i = 0; i < typeSig.length-1; i++) sig.append(typeSig[i]); // copy all but trailing semicolon	370	if (this.isMemberType()) {
374	}	371	ReferenceBinding enclosing = enclosingType();
375	if (this.arguments != null) {	372	boolean hasParameterizedEnclosing = enclosing.isParameterizedType();
376	sig.append('<');	373	char[] typeSig = hasParameterizedEnclosing ? enclosing.genericTypeSignature() : enclosing.signature();
377	for (int i = 0, length = this.arguments.length; i < length; i++) {	374	sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
378	sig.append(this.arguments[i].genericTypeSignature());	375	if (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0) {
379	}	376	// if (this.arguments != null \|\| (hasParameterizedEnclosing && (enclosing.modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)) {
380	sig.append('>');	377	sig.append('.');
381	}	378	} else {
382	sig.append(';');	379	sig.append('$');
383	int sigLength = sig.length();	380	}
384	this.genericTypeSignature = new char[sigLength];	381	sig.append(this.sourceName());
385	sig.getChars(0, sigLength, this.genericTypeSignature, 0);	382	} else {
386	}	383	char[] typeSig = this.type.signature();
387	return this.genericTypeSignature;	384	sig.append(typeSig, 0, typeSig.length-1);// copy all but trailing semicolon
		385	}
		386	if (this.arguments != null) {
		387	sig.append('<');
		388	for (int i = 0, length = this.arguments.length; i < length; i++) {
		389	sig.append(this.arguments[i].genericTypeSignature());
		390	}
		391	sig.append('>');
		392	}
		393	sig.append(';');
		394	int sigLength = sig.length();
		395	this.genericTypeSignature = new char[sigLength];
		396	sig.getChars(0, sigLength, this.genericTypeSignature, 0);
		397	}
		398	}
		399	return this.genericTypeSignature;
388	}	400	}
389		401
390	/**	402	/**

Lines 38065-38068 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (+320 lines)
38065	false, // do not flush output	38065	false, // do not flush output
38066	null);	38066	null);
38067	}	38067	}
		38068	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158
		38069	public void test1150() {
		38070	this.runConformTest(
		38071	new String[] {
		38072	"X.java",
		38073	"import java.lang.ref.Reference;\n"+
		38074	"public class X<T> {\n" +
		38075	" static class Rather {\n" +
		38076	" static class Deeply {\n" +
		38077	" static class Inside {\n" +
		38078	" }\n" +
		38079	" }\n" +
		38080	" }\n" +
		38081	" Reference<X.Rather.Deeply> x;\n" +
		38082	" Reference<X.Rather> y; \n" +
		38083	" Reference<X.Rather.Deeply.Inside> z; \n" +
		38084	"\n" +
		38085	" public static void main(String[] args) throws Exception {\n" +
		38086	" System.out.print(X.class.getDeclaredField(\"x\").getGenericType());\n" +
		38087	" System.out.print(\"##\");\n" +
		38088	" System.out.print(X.class.getDeclaredField(\"y\").getGenericType());\n" +
		38089	" System.out.print(\"##\");\n" +
		38090	" System.out.print(X.class.getDeclaredField(\"z\").getGenericType());\n" +
		38091	" System.out.println();\n" +
		38092	" }\n" +
		38093	"}\n"
		38094	},
		38095	"java.lang.ref.Reference<X$Rather$Deeply>##java.lang.ref.Reference<X$Rather>##java.lang.ref.Reference<X$Rather$Deeply$Inside>"
		38096	);
		38097	String expectedOutput =
		38098	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
		38099	" // Signature: Ljava/lang/ref/Reference<LX$Rather$Deeply;>;\n" +
		38100	" java.lang.ref.Reference x;\n" +
		38101	" \n" +
		38102	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
		38103	" // Signature: Ljava/lang/ref/Reference<LX$Rather;>;\n" +
		38104	" java.lang.ref.Reference y;\n" +
		38105	" \n" +
		38106	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
		38107	" // Signature: Ljava/lang/ref/Reference<LX$Rather$Deeply$Inside;>;\n" +
		38108	" java.lang.ref.Reference z;\n";
		38109
		38110	try {
		38111	File f = new File(OUTPUT_DIR + File.separator + "X.class");
		38112	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		38113	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		38114	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		38115	int index = result.indexOf(expectedOutput);
		38116	if (index == -1 \|\| expectedOutput.length() == 0) {
		38117	System.out.println(Util.displayString(result, 3));
		38118	}
		38119	if (index == -1) {
		38120	assertEquals("Wrong contents", expectedOutput, result);
		38121	}
		38122	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		38123	assertTrue(false);
		38124	} catch (IOException e) {
		38125	assertTrue(false);
		38126	}
		38127
		38128	}
		38129	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
		38130	public void test1151() {
		38131	this.runConformTest(
38132	new String[] {
38133	"X.java",
38134	"import java.lang.ref.Reference;\n"+
38135	"public class X<T> {\n" +
38136	" class Other<U> {\n" +
38137	" class Deeply {\n" +
38138	" class Inside<V> {\n" +
38139	" } \n" +
38140	" }\n" +
38141	" }\n" +
38142	" Reference<X<String>.Other<Thread>.Deeply> t;\n" +
38143	" Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" +
38144	"\n" +
38145	" public static void main(String[] args) throws Exception {\n" +
38146	" System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" +
38147	" //System.out.print(\"##\");\n" +
38148	" //System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
38149	" System.out.println();\n" +
38150	" }\n" +
38151	"}\n"
38152	},
38153	//"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>##java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply$Inside<java.lang.Number>>"
38154	"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>"
38155	);
38156	String expectedOutput =
38157	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38158	" // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply;>;\n" +
38159	" java.lang.ref.Reference t;\n" +
38160	" \n" +
38161	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38162	" // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply.Inside<Ljava/lang/Number;>;>;\n" +
38163	" java.lang.ref.Reference u;\n";
38164
38165	try {
38166	File f = new File(OUTPUT_DIR + File.separator + "X.class");
38167	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
38168	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
38169	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
38170	int index = result.indexOf(expectedOutput);
38171	if (index == -1 \|\| expectedOutput.length() == 0) {
38172	System.out.println(Util.displayString(result, 3));
38173	}
38174	if (index == -1) {
38175	assertEquals("Wrong contents", expectedOutput, result);
38176	}
38177	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
38178	assertTrue(false);
38179	} catch (IOException e) {
38180	assertTrue(false);
38181	}
38182	}
38183	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
38184	public void test1152() {
38185	this.runNegativeTest(
38186	new String[] {
38187	"X.java",
38188	"import java.lang.ref.Reference;\n"+
38189	"public class X<T> {\n" +
38190	" class Other<U> {\n" +
38191	" class Deeply {\n" +
38192	" class Inside<V> {\n" +
38193	" } \n" +
38194	" }\n" +
38195	" }\n" +
38196	" Reference<X<String>.Other<Thread>.Deeply.Inside> u;\n" +
38197	"\n" +
38198	" public static void main(String[] args) throws Exception {\n" +
38199	" System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" +
38200	" System.out.println();\n" +
38201	" }\n" +
38202	"}\n"
38203	},
38204	"----------\n" +
38205	"1. ERROR in X.java (at line 9)\n" +
38206	" Reference<X<String>.Other<Thread>.Deeply.Inside> u;\n" +
38207	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
38208	"The member type X<String>.Other<Thread>.Deeply.Inside must be parameterized, since it is qualified with a parameterized type\n" +
38209	"----------\n" );
38210	}
38211	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
38212	public void test1153() {
38213	// check proper decoding of binary signatures, by compiling against generated binary
38214	this.runConformTest(
38215	new String[] {
38216	"p/X.java",
38217	"package p;\n" +
38218	"import java.lang.ref.Reference;\n" +
38219	"public class X<T> {\n" +
38220	" public static class Rather {\n" +
38221	" public static class Deeply {\n" +
38222	" public static class Inside {\n" +
38223	" }\n" +
38224	" }\n" +
38225	" }\n" +
38226	" public class Other<U> {\n" +
38227	" public class Deeply {\n" +
38228	" public class Inside<V> {\n" +
38229	" } \n" +
38230	" }\n" +
38231	" }\n" +
38232	" public Reference<X.Rather.Deeply> x;\n" +
38233	" public Reference<X.Rather> y; \n" +
38234	" public Reference<X.Rather.Deeply.Inside> z; \n" +
38235	" public Reference<X<String>.Other<Thread>.Deeply> t;\n" +
38236	" public Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" +
38237	"}\n",
38238	},
38239	""
38240	);
38241	this.runConformTest(
38242	new String[] {
38243	"Y.java",
38244	"import java.lang.ref.Reference;\n" +
38245	"import p.X;\n" +
38246	"public class Y {\n" +
38247	" Reference<X.Rather.Deeply> x;\n" +
38248	" Reference<X.Rather> y; \n" +
38249	" Reference<X.Rather.Deeply.Inside> z; \n" +
38250	" Reference<X<String>.Other<Thread>.Deeply> t;\n" +
38251	" Reference<X<String>.Other<Thread>.Deeply.Inside<Number>> u;\n" +
38252	" Y(X someX) {\n" +
38253	" this.x = someX.x;\n" +
38254	" this. y = someX.y; \n" +
38255	" this.z = someX.z; \n" +
38256	" this.t = someX.t;\n" +
38257	" this.u = someX.u; \n" +
38258	" }\n" +
38259	" public static void main(String[] args) throws Exception {\n" +
38260	" System.out.print(Y.class.getDeclaredField(\"x\").getGenericType());\n" +
38261	" System.out.print(\"##\");\n" +
38262	" System.out.print(Y.class.getDeclaredField(\"y\").getGenericType());\n" +
38263	" System.out.print(\"##\");\n" +
38264	" System.out.print(Y.class.getDeclaredField(\"z\").getGenericType());\n" +
38265	" System.out.print(\"##\");\n" +
38266	" System.out.print(Y.class.getDeclaredField(\"t\").getGenericType());\n" +
38267	" //System.out.print(\"##\");\n" +
38268	" //System.out.print(Y.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
38269	" System.out.println();\n" +
38270	" }\n" +
38271	"}\n"
38272	},
38273	"java.lang.ref.Reference<p.X$Rather$Deeply>##java.lang.ref.Reference<p.X$Rather>##java.lang.ref.Reference<p.X$Rather$Deeply$Inside>##java.lang.ref.Reference<p.X<java.lang.String>.Other<java.lang.Thread>.Deeply>",
38274	null,
38275	false, // do not flush output
38276	null);
38277	}
38278	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
38279	public void test1154() {
38280	this.runConformTest(
38281	new String[] {
38282	"X.java",
38283	"import java.lang.ref.Reference;\n" +
38284	"public class X {\n" +
38285	" class Other<U> {\n" +
38286	" class Deeply {\n" +
38287	" class Deeper {\n" +
38288	" class Inside<V> {\n" +
38289	" } \n" +
38290	" }\n" +
38291	" }\n" +
38292	" }\n" +
38293	" Reference<X.Other<Thread>.Deeply> t;\n" +
38294	" Reference<X.Other<Thread>.Deeply.Deeper.Inside<Number>> u;\n" +
38295	"\n" +
38296	" public static void main(String[] args) throws Exception {\n" +
38297	" //System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
38298	" //System.out.print(\"##\");\n" +
38299	" //System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
38300	" System.out.println();\n" +
38301	" }\n" +
38302	"}\n"
38303	},
38304	"");
38305
38306	String expectedOutput =
38307	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38308	" // Signature: Ljava/lang/ref/Reference<LX$Other<Ljava/lang/Thread;>.Deeply;>;\n" +
38309	" java.lang.ref.Reference t;\n" +
38310	" \n" +
38311	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38312	" // Signature: Ljava/lang/ref/Reference<LX$Other<Ljava/lang/Thread;>.Deeply.Deeper.Inside<Ljava/lang/Number;>;>;\n" +
38313	" java.lang.ref.Reference u;\n";
38314
38315	try {
38316	File f = new File(OUTPUT_DIR + File.separator + "X.class");
38317	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
38318	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
38319	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
38320	int index = result.indexOf(expectedOutput);
38321	if (index == -1 \|\| expectedOutput.length() == 0) {
38322	System.out.println(Util.displayString(result, 3));
38323	}
38324	if (index == -1) {
38325	assertEquals("Wrong contents", expectedOutput, result);
38326	}
38327	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
38328	assertTrue(false);
38329	} catch (IOException e) {
38330	assertTrue(false);
38331	}
38332	}
38333	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=189158 - variation
38334	public void test1155() {
38335	this.runConformTest(
38336	new String[] {
38337	"X.java",
38338	"import java.lang.ref.Reference;\n" +
38339	"public class X<T> {\n" +
38340	" class Other<U> {\n" +
38341	" class Deeply {\n" +
38342	" class Deeper {\n" +
38343	" class Inside<V> {\n" +
38344	" } \n" +
38345	" }\n" +
38346	" }\n" +
38347	" }\n" +
38348	" Reference<X<String>.Other<Thread>.Deeply> t;\n" +
38349	" Reference<X<String>.Other<Thread>.Deeply.Deeper.Inside<Number>> u;\n" +
38350	"\n" +
38351	" public static void main(String[] args) throws Exception {\n" +
38352	" System.out.print(X.class.getDeclaredField(\"t\").getGenericType());\n" +
38353	" //System.out.print(\"##\");\n" +
38354	" //System.out.print(X.class.getDeclaredField(\"u\").getGenericType());\n" + // TODO disabled due to bug in libs (unable to re-read the generated signature)
38355	" System.out.println();\n" +
38356	" }\n" +
38357	"}\n"
38358	},
38359	"java.lang.ref.Reference<X<java.lang.String>.Other<java.lang.Thread>.Deeply>" );
38360
38361	String expectedOutput =
38362	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38363	" // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply;>;\n" +
38364	" java.lang.ref.Reference t;\n" +
38365	" \n" +
38366	" // Field descriptor #6 Ljava/lang/ref/Reference;\n" +
38367	" // Signature: Ljava/lang/ref/Reference<LX<Ljava/lang/String;>.Other<Ljava/lang/Thread;>.Deeply.Deeper.Inside<Ljava/lang/Number;>;>;\n" +
38368	" java.lang.ref.Reference u;\n";
38369
38370	try {
38371	File f = new File(OUTPUT_DIR + File.separator + "X.class");
38372	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
38373	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
38374	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
38375	int index = result.indexOf(expectedOutput);
38376	if (index == -1 \|\| expectedOutput.length() == 0) {
38377	System.out.println(Util.displayString(result, 3));
38378	}
38379	if (index == -1) {
38380	assertEquals("Wrong contents", expectedOutput, result);
38381	}
38382	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
38383	assertTrue(false);
38384	} catch (IOException e) {
38385	assertTrue(false);
38386	}
38387	}
38068	}	38388	}