Attachment #77026 for bug #201104




	 * http://dev.eclipse.org/bugs/show_bug.cgi?id=180905
	 */
	public void test0676() throws JavaModelException {
		ICompilationUnit sourceUnit = getCompilationUnit("Converter" , "src", "test0676", "X.java"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		ASTNode node = runConversion(AST.JLS3, sourceUnit, true, true, true);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		assertTrue("no binding recovery", unit.getAST().hasBindingsRecovery());
		assertTrue("no statement recovery", unit.getAST().hasStatementsRecovery());
		assertTrue("no binding resolution", unit.getAST().hasResolvedBindings());
		String expectedError = "B cannot be resolved to a type";
		assertProblemsSize(unit, 1, expectedError);
		assertTrue("No binding recovery", unit.getAST().hasBindingsRecovery());
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		Type type = methodDeclaration.getReturnType2();
		assertNotNull("No type", type);
		ITypeBinding typeBinding = type.resolveBinding();
		assertNotNull("No type binding", typeBinding);
		assertTrue("Not a recovered binding", typeBinding.isRecovered());
		IJavaElement javaElement = typeBinding.getJavaElement();
		assertNotNull("No java element", javaElement);
		assertTrue("Java element exists", !javaElement.exists());
		IPackageBinding packageBinding = typeBinding.getPackage();
		assertNotNull("No package", packageBinding);
		assertNotNull("No java element for package", packageBinding.getJavaElement());
		assertEquals("Not the package test0676", "test0676", packageBinding.getName());
		ITypeBinding arrayBinding = typeBinding.createArrayType(2);
		assertNotNull("No array binding", arrayBinding);
		assertEquals("Wrong dimensions", 2, arrayBinding.getDimensions());
		ITypeBinding elementType = arrayBinding.getElementType();
		assertNotNull("No element type", elementType);
		assertNotNull("No key", typeBinding.getKey());
		assertTrue("Not equals", elementType.isEqualTo(typeBinding));
		
		node = getASTNode(unit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		ITypeBinding typeBinding2 = typeDeclaration.resolveBinding();
		ITypeBinding javaLangObject = typeBinding2.getSuperclass();
		assertEquals("Not java.lang.Object", "java.lang.Object", javaLangObject.getQualifiedName());
		assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(javaLangObject));
		assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(elementType));
			node = getASTNode(unit, 0);
			assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
			TypeDeclaration typeDeclaration = (TypeDeclaration) node;
			ITypeBinding typeBinding2 = typeDeclaration.resolveBinding();
			ITypeBinding javaLangObject = typeBinding2.getSuperclass();
			assertEquals("Not java.lang.Object", "java.lang.Object", javaLangObject.getQualifiedName());
			assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(javaLangObject));
			assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(elementType));

		assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(javaLangObject));
		assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(elementType));

		assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(javaLangObject));
		assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(elementType));
		} finally {
			if (workingCopy != null)
				workingCopy.discardWorkingCopy();
		}
	}
	
	/**




		IAnnotationBinding[] annotations = typeBinding.getAnnotations();
		assertEquals("wrong size", 1, annotations.length);
	}
	

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=201104
	public void test0282() throws JavaModelException {
		String contents =
			"public class X {\n" + 
			"	public @interface Moo {\n" + 
			"		Class<?> value();\n" + 
			"	}\n" + 
			"	@Moo(Bar2.Baz.class)\n" + 
			"	public static class Bar {\n" + 
			"		public static class Baz {\n" + 
			"		}\n" + 
			"	}\n" + 
			"}";
		workingCopy = getWorkingCopy("/Converter15/src/X.java", true/*resolve*/);
		workingCopy.getBuffer().setContents(contents);
		ASTNode node = runConversion(AST.JLS3, workingCopy, true, true, true);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		assertProblemsSize(unit, 1, "Bar2 cannot be resolved to a type");
		node = getASTNode(unit, 0, 1);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		final List modifiers = typeDeclaration.modifiers();
		assertEquals("Wrong size", 3, modifiers.size());
		IExtendedModifier extendedModifier = (IExtendedModifier) modifiers.get(0);
		assertTrue("Not an annotation", extendedModifier instanceof SingleMemberAnnotation);
		SingleMemberAnnotation annotation = (SingleMemberAnnotation) extendedModifier;
		final Expression value = annotation.getValue();
		assertEquals("Not a type literal", ASTNode.TYPE_LITERAL, value.getNodeType());
		TypeLiteral typeLiteral = (TypeLiteral) value;
		final Type type = typeLiteral.getType();
		assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, type.getNodeType());
		SimpleType simpleType = (SimpleType) type;
		final Name name = simpleType.getName();
		assertEquals("Not a qualified name", ASTNode.QUALIFIED_NAME, name.getNodeType());
		QualifiedName qualifiedName = (QualifiedName) name;
		final IBinding binding = qualifiedName.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong value", "Bar2.Baz", qualifiedName.getFullyQualifiedName());
		final Name qualifier = qualifiedName.getQualifier();
		assertEquals("Not a simple name", ASTNode.SIMPLE_NAME, qualifier.getNodeType());
		SimpleName simpleName2 = (SimpleName) qualifier;
		final IBinding binding3 = simpleName2.resolveBinding();
		assertNotNull("No binding3", binding3);
		assertTrue("Not a recovered binding", binding3.isRecovered());
		final IJavaElement javaElement = binding3.getJavaElement();
		assertNotNull("No java element", javaElement);
		assertEquals("Not a compilation unit", IJavaElement.COMPILATION_UNIT, javaElement.getElementType());
		assertNotNull("No parent", javaElement.getParent());
	}	
}

Added Link Here

(-)workspace/Converter/src/test0676/X.java (+5 lines)
1	package test0676;
2	public class X {
3	B foo() {
4	}
5	}

Lines 19-24 Link Here

(-)dom/org/eclipse/jdt/core/dom/RecoveredTypeBinding.java (-1 / +8 lines)
19	import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;	19	import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
20	import org.eclipse.jdt.internal.compiler.util.Util;	20	import org.eclipse.jdt.internal.compiler.util.Util;
21	import org.eclipse.jdt.internal.core.CompilationUnit;	21	import org.eclipse.jdt.internal.core.CompilationUnit;
		22	import org.eclipse.jdt.internal.core.PackageFragment;
22		23
23	/**	24	/**
24	* This class represents the recovered binding for a type	25	* This class represents the recovered binding for a type
Lines 495-501 Link Here
495	*/	496	*/
496	public IJavaElement getJavaElement() {	497	public IJavaElement getJavaElement() {
497	try {	498	try {
498	return new CompilationUnit(null, this.getInternalName(), this.resolver.getWorkingCopyOwner()).getWorkingCopy(this.resolver.getWorkingCopyOwner(), null);	499	IPackageBinding packageBinding = getPackage();
		500	if (packageBinding != null) {
		501	final IJavaElement javaElement = packageBinding.getJavaElement();
		502	if (javaElement!= null && javaElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
		503	return new CompilationUnit((PackageFragment) javaElement, this.getInternalName(), this.resolver.getWorkingCopyOwner()).getWorkingCopy(this.resolver.getWorkingCopyOwner(), null);
		504	}
		505	}
499	} catch (JavaModelException e) {	506	} catch (JavaModelException e) {
500	//ignore	507	//ignore
501	}	508	}

Return to bug 201104

Lines 9144-9208 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTestAST3_2.java (-57 / +45 lines)
9144	* http://dev.eclipse.org/bugs/show_bug.cgi?id=180905	9144	* http://dev.eclipse.org/bugs/show_bug.cgi?id=180905
9145	*/	9145	*/
9146	public void test0676() throws JavaModelException {	9146	public void test0676() throws JavaModelException {
9147	ICompilationUnit workingCopy = null;	9147	ICompilationUnit sourceUnit = getCompilationUnit("Converter" , "src", "test0676", "X.java"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
9148	try {	9148	ASTNode node = runConversion(AST.JLS3, sourceUnit, true, true, true);
9149	String contents =	9149	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
9150	"package p;\n" +	9150	CompilationUnit unit = (CompilationUnit) node;
9151	"public class X {\n" +	9151	assertTrue("no binding recovery", unit.getAST().hasBindingsRecovery());
9152	" B foo() {\n" +	9152	assertTrue("no statement recovery", unit.getAST().hasStatementsRecovery());
9153	" }\n" +	9153	assertTrue("no binding resolution", unit.getAST().hasResolvedBindings());
9154	"}";	9154	String expectedError = "B cannot be resolved to a type";
9155	workingCopy = getWorkingCopy("/Converter/src/p/X.java", true/resolve/);	9155	assertProblemsSize(unit, 1, expectedError);
9156	workingCopy.getBuffer().setContents(contents);	9156	assertTrue("No binding recovery", unit.getAST().hasBindingsRecovery());
9157	ASTNode node = runConversion(AST.JLS3, workingCopy, true, true, true);	9157	node = getASTNode(unit, 0, 0);
9158	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());	9158	assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
9159	CompilationUnit unit = (CompilationUnit) node;	9159	MethodDeclaration methodDeclaration = (MethodDeclaration) node;
9160	assertTrue("no binding recovery", unit.getAST().hasBindingsRecovery());	9160	Type type = methodDeclaration.getReturnType2();
9161	assertTrue("no statement recovery", unit.getAST().hasStatementsRecovery());	9161	assertNotNull("No type", type);
9162	assertTrue("no binding resolution", unit.getAST().hasResolvedBindings());	9162	ITypeBinding typeBinding = type.resolveBinding();
9163	String expectedError = "B cannot be resolved to a type";	9163	assertNotNull("No type binding", typeBinding);
9164	assertProblemsSize(unit, 1, expectedError);	9164	assertTrue("Not a recovered binding", typeBinding.isRecovered());
9165	assertTrue("No binding recovery", unit.getAST().hasBindingsRecovery());	9165	IJavaElement javaElement = typeBinding.getJavaElement();
9166	node = getASTNode(unit, 0, 0);	9166	assertNotNull("No java element", javaElement);
9167	assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());	9167	assertTrue("Java element exists", !javaElement.exists());
9168	MethodDeclaration methodDeclaration = (MethodDeclaration) node;	9168	IPackageBinding packageBinding = typeBinding.getPackage();
9169	Type type = methodDeclaration.getReturnType2();	9169	assertNotNull("No package", packageBinding);
9170	assertNotNull("No type", type);	9170	assertNotNull("No java element for package", packageBinding.getJavaElement());
9171	ITypeBinding typeBinding = type.resolveBinding();	9171	assertEquals("Not the package test0676", "test0676", packageBinding.getName());
9172	assertNotNull("No type binding", typeBinding);	9172	ITypeBinding arrayBinding = typeBinding.createArrayType(2);
9173	assertTrue("Not a recovered binding", typeBinding.isRecovered());	9173	assertNotNull("No array binding", arrayBinding);
9174	IJavaElement javaElement = typeBinding.getJavaElement();	9174	assertEquals("Wrong dimensions", 2, arrayBinding.getDimensions());
9175	assertNotNull("No java element", javaElement);	9175	ITypeBinding elementType = arrayBinding.getElementType();
9176	assertTrue("Javalement exists", !javaElement.exists());	9176	assertNotNull("No element type", elementType);
9177	IPackageBinding packageBinding = typeBinding.getPackage();	9177	assertNotNull("No key", typeBinding.getKey());
9178	assertNotNull("No package", packageBinding);	9178	assertTrue("Not equals", elementType.isEqualTo(typeBinding));
9179	assertEquals("Not the package p", "p", packageBinding.getName());	9179
9180	ITypeBinding arrayBinding = typeBinding.createArrayType(2);	9180	node = getASTNode(unit, 0);
9181	assertNotNull("No array binding", arrayBinding);	9181	assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
9182	assertEquals("Wrong dimensions", 2, arrayBinding.getDimensions());	9182	TypeDeclaration typeDeclaration = (TypeDeclaration) node;
9183	ITypeBinding elementType = arrayBinding.getElementType();	9183	ITypeBinding typeBinding2 = typeDeclaration.resolveBinding();
9184	assertNotNull("No element type", elementType);	9184	ITypeBinding javaLangObject = typeBinding2.getSuperclass();
9185	assertNotNull("No key", typeBinding.getKey());	9185	assertEquals("Not java.lang.Object", "java.lang.Object", javaLangObject.getQualifiedName());
9186	assertTrue("Not equals", elementType.isEqualTo(typeBinding));	9186	assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(javaLangObject));
9187		9187	assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(elementType));
9188	node = getASTNode(unit, 0);
9189	assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
9190	TypeDeclaration typeDeclaration = (TypeDeclaration) node;
9191	ITypeBinding typeBinding2 = typeDeclaration.resolveBinding();
9192	ITypeBinding javaLangObject = typeBinding2.getSuperclass();
9193	assertEquals("Not java.lang.Object", "java.lang.Object", javaLangObject.getQualifiedName());
9194	assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(javaLangObject));
9195	assertTrue("Not isCastCompatible", typeBinding.isCastCompatible(elementType));
9196		9188
9197	assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(javaLangObject));	9189	assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(javaLangObject));
9198	assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(elementType));	9190	assertTrue("Not isSubTypeCompatible", typeBinding.isSubTypeCompatible(elementType));
9199		9191
9200	assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(javaLangObject));	9192	assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(javaLangObject));
9201	assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(elementType));	9193	assertTrue("Not isAssignmentCompatible", typeBinding.isAssignmentCompatible(elementType));
9202	} finally {
9203	if (workingCopy != null)
9204	workingCopy.discardWorkingCopy();
9205	}
9206	}	9194	}
9207		9195
9208	/**	9196	/**

Lines 9344-9347 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java (+52 lines)
9344	IAnnotationBinding[] annotations = typeBinding.getAnnotations();	9344	IAnnotationBinding[] annotations = typeBinding.getAnnotations();
9345	assertEquals("wrong size", 1, annotations.length);	9345	assertEquals("wrong size", 1, annotations.length);
9346	}	9346	}
		9347
		9348
		9349	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=201104
		9350	public void test0282() throws JavaModelException {
		9351	String contents =
		9352	"public class X {\n" +
		9353	" public @interface Moo {\n" +
		9354	" Class<?> value();\n" +
		9355	" }\n" +
		9356	" @Moo(Bar2.Baz.class)\n" +
		9357	" public static class Bar {\n" +
		9358	" public static class Baz {\n" +
		9359	" }\n" +
		9360	" }\n" +
		9361	"}";
		9362	workingCopy = getWorkingCopy("/Converter15/src/X.java", true/resolve/);
		9363	workingCopy.getBuffer().setContents(contents);
		9364	ASTNode node = runConversion(AST.JLS3, workingCopy, true, true, true);
		9365	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		9366	CompilationUnit unit = (CompilationUnit) node;
		9367	assertProblemsSize(unit, 1, "Bar2 cannot be resolved to a type");
		9368	node = getASTNode(unit, 0, 1);
		9369	assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		9370	TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		9371	final List modifiers = typeDeclaration.modifiers();
		9372	assertEquals("Wrong size", 3, modifiers.size());
		9373	IExtendedModifier extendedModifier = (IExtendedModifier) modifiers.get(0);
		9374	assertTrue("Not an annotation", extendedModifier instanceof SingleMemberAnnotation);
		9375	SingleMemberAnnotation annotation = (SingleMemberAnnotation) extendedModifier;
		9376	final Expression value = annotation.getValue();
		9377	assertEquals("Not a type literal", ASTNode.TYPE_LITERAL, value.getNodeType());
		9378	TypeLiteral typeLiteral = (TypeLiteral) value;
		9379	final Type type = typeLiteral.getType();
		9380	assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, type.getNodeType());
		9381	SimpleType simpleType = (SimpleType) type;
		9382	final Name name = simpleType.getName();
		9383	assertEquals("Not a qualified name", ASTNode.QUALIFIED_NAME, name.getNodeType());
		9384	QualifiedName qualifiedName = (QualifiedName) name;
		9385	final IBinding binding = qualifiedName.resolveBinding();
		9386	assertNotNull("No binding", binding);
		9387	assertEquals("Wrong value", "Bar2.Baz", qualifiedName.getFullyQualifiedName());
		9388	final Name qualifier = qualifiedName.getQualifier();
		9389	assertEquals("Not a simple name", ASTNode.SIMPLE_NAME, qualifier.getNodeType());
		9390	SimpleName simpleName2 = (SimpleName) qualifier;
		9391	final IBinding binding3 = simpleName2.resolveBinding();
		9392	assertNotNull("No binding3", binding3);
		9393	assertTrue("Not a recovered binding", binding3.isRecovered());
		9394	final IJavaElement javaElement = binding3.getJavaElement();
		9395	assertNotNull("No java element", javaElement);
		9396	assertEquals("Not a compilation unit", IJavaElement.COMPILATION_UNIT, javaElement.getElementType());
		9397	assertNotNull("No parent", javaElement.getParent());
		9398	}
9347	}	9399	}