Attachment #115910 for bug #248309

View | Details | Raw Unified | Return to bug 248309
Collapse All | Expand All




 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.util.ArrayList;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModelStatusConstants;
import org.eclipse.jdt.core.IMemberValuePair;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.env.ClassSignature;
import org.eclipse.jdt.internal.compiler.env.EnumConstantSignature;
import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.core.util.Util;

/**
 * Common functionality for Binary member handles.
 */
public abstract class BinaryMember extends NamedMember {
		
/*
 * Constructs a binary member.
 */

public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
}
protected IAnnotation[] getAnnotations(IBinaryAnnotation[] binaryAnnotations, long tagBits) {
	IAnnotation[] standardAnnotations = getStandardAnnotations(tagBits);
	if (binaryAnnotations == null)
		return standardAnnotations;
	int length = binaryAnnotations.length;
	int standardLength = standardAnnotations.length;
	IAnnotation[] annotations = new IAnnotation[length + standardLength];
	for (int i = 0; i < length; i++) {
		annotations[i] = Util.getAnnotation(this, binaryAnnotations[i]);
	}
	System.arraycopy(standardAnnotations, 0, annotations, length, standardLength);
	return annotations;
}
private IAnnotation getAnnotation(char[][] annotationName) {
	return new Annotation(this, new String(CharOperation.concatWith(annotationName, '.')));
	int pairsLength = binaryElementValuePairs.length;
	final IMemberValuePair[] members;
	if (pairsLength == 0) {
		members = Annotation.NO_MEMBER_VALUE_PAIRS;
	} else {
		members = new IMemberValuePair[pairsLength];
		for (int i = 0; i < pairsLength; i++) {
			IBinaryElementValuePair binaryElementValuePair = binaryElementValuePairs[i];
			MemberValuePair memberValuePair = new MemberValuePair(new String(binaryElementValuePair.getName()));
			memberValuePair.value = getMemberValue(memberValuePair, binaryElementValuePair.getValue());
			members[i] = memberValuePair;
		}
	}
	char[] typeName = org.eclipse.jdt.core.Signature.toCharArray(CharOperation.replaceOnCopy(binaryAnnotation.getTypeName(), '/', '.'));
	return new Annotation(this, new String(typeName)) {
		public IMemberValuePair[] getMemberValuePairs() throws JavaModelException {
			return members;
		}
	};
}
private IAnnotation[] getStandardAnnotations(long tagBits) {
	if ((tagBits & TagBits.AllStandardAnnotationsMask) == 0)
		return Annotation.NO_ANNOTATIONS;
	ArrayList annotations = new ArrayList();

	if ((tagBits & TagBits.AnnotationTargetMASK) != 0) {
		annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_TARGET));
	}
	if ((tagBits & TagBits.AnnotationRetentionMASK) != 0) {
		annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_RETENTION));
	} else if (binaryValue instanceof EnumConstantSignature) {
		memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
		EnumConstantSignature enumConstant = (EnumConstantSignature) binaryValue;
		char[] enumName = Signature.toCharArray(CharOperation.replaceOnCopy(enumConstant.getTypeName(), '/', '.'));
		char[] qualifiedName = CharOperation.concat(enumName, enumConstant.getEnumConstantName(), '.');
		return new String(qualifiedName);
	} else if (binaryValue instanceof Object[]) {
		memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
		Object[] binaryValues = (Object[]) binaryValue;
		int length = binaryValues.length;
		Object[] values = new Object[length];
		for (int i = 0; i < length; i++) {
			int previousValueKind = memberValuePair.valueKind;
			Object value = getMemberValue(memberValuePair, binaryValues[i]);
			if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
				// values are heterogeneous, value kind is thus unknown
				memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
			}
			values[i] = value;
		}
		if (memberValuePair.valueKind == -1)
			memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
		return values;
	} else {
		memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
		return null;
	}
	if ((tagBits & TagBits.AnnotationDeprecated) != 0) {
		annotations.add(getAnnotation(TypeConstants.JAVA_LANG_DEPRECATED));
	}
	if ((tagBits & TagBits.AnnotationDocumented) != 0) {
		annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED));
	}
	if ((tagBits & TagBits.AnnotationInherited) != 0) {
		annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_INHERITED));
	}
	// note that JAVA_LANG_SUPPRESSWARNINGS and JAVA_LANG_OVERRIDE cannot appear in binaries
	return (IAnnotation[]) annotations.toArray(new IAnnotation[annotations.size()]);
}

public String[] getCategories() throws JavaModelException {
	SourceMapper mapper= getSourceMapper();
	if (mapper != null) {

Lines 16-21 Link Here

(-)model/org/eclipse/jdt/internal/core/Annotation.java (-4 / +22 lines)
16	import org.eclipse.jdt.core.IMemberValuePair;	16	import org.eclipse.jdt.core.IMemberValuePair;
17	import org.eclipse.jdt.core.ISourceRange;	17	import org.eclipse.jdt.core.ISourceRange;
18	import org.eclipse.jdt.core.JavaModelException;	18	import org.eclipse.jdt.core.JavaModelException;
		19	import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
		20	import org.eclipse.jdt.internal.compiler.env.IBinaryElementValuePair;
		21	import org.eclipse.jdt.internal.core.util.Util;
19		22
20	public class Annotation extends SourceRefElement implements IAnnotation {	23	public class Annotation extends SourceRefElement implements IAnnotation {
21		24
Lines 51-58 Link Here
51	}	54	}
52		55
53	public IMemberValuePair[] getMemberValuePairs() throws JavaModelException {	56	public IMemberValuePair[] getMemberValuePairs() throws JavaModelException {
54	AnnotationInfo info = (AnnotationInfo) getElementInfo();	57	Object info = getElementInfo();
55	return info.members;	58	if (info instanceof AnnotationInfo)
		59	return ((AnnotationInfo) info).members;
		60	IBinaryElementValuePair[] binaryAnnotations = ((IBinaryAnnotation) info).getElementValuePairs();
		61	int length = binaryAnnotations.length;
		62	IMemberValuePair[] result = new IMemberValuePair[length];
		63	for (int i = 0; i < length; i++) {
		64	IBinaryElementValuePair binaryAnnotation = binaryAnnotations[i];
		65	MemberValuePair memberValuePair = new MemberValuePair(new String(binaryAnnotation.getName()));
		66	memberValuePair.value = Util.getAnnotationMemberValue(this, memberValuePair, binaryAnnotation.getValue());
		67	result[i] = memberValuePair;
		68	}
		69	return result;
56	}	70	}
57		71
58	public ISourceRange getNameRange() throws JavaModelException {	72	public ISourceRange getNameRange() throws JavaModelException {
Lines 65-72 Link Here
65	return mapper.getNameRange(this);	79	return mapper.getNameRange(this);
66	}	80	}
67	}	81	}
68	AnnotationInfo info = (AnnotationInfo) getElementInfo();	82	Object info = getElementInfo();
69	return new SourceRange(info.nameStart, info.nameEnd - info.nameStart + 1);	83	if (info instanceof AnnotationInfo) {
		84	AnnotationInfo annotationInfo = (AnnotationInfo) info;
		85	return new SourceRange(annotationInfo.nameStart, annotationInfo.nameEnd - annotationInfo.nameStart + 1);
		86	}
		87	return null;
70	}	88	}
71		89
72	/*	90	/*

Lines 40-46 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryField.java (-1 / +1 lines)
40	public IAnnotation[] getAnnotations() throws JavaModelException {	40	public IAnnotation[] getAnnotations() throws JavaModelException {
41	IBinaryField info = (IBinaryField) getElementInfo();	41	IBinaryField info = (IBinaryField) getElementInfo();
42	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();	42	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();
43	return getAnnotations(binaryAnnotations);	43	return getAnnotations(binaryAnnotations, info.getTagBits());
44	}	44	}
45	/*	45	/*
46	* @see IField	46	* @see IField

Lines 57-63 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryMethod.java (-2 / +2 lines)
57	public IAnnotation[] getAnnotations() throws JavaModelException {	57	public IAnnotation[] getAnnotations() throws JavaModelException {
58	IBinaryMethod info = (IBinaryMethod) getElementInfo();	58	IBinaryMethod info = (IBinaryMethod) getElementInfo();
59	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();	59	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();
60	return getAnnotations(binaryAnnotations);	60	return getAnnotations(binaryAnnotations, info.getTagBits());
61	}	61	}
62	public IMemberValuePair getDefaultValue() throws JavaModelException {	62	public IMemberValuePair getDefaultValue() throws JavaModelException {
63	IBinaryMethod info = (IBinaryMethod) getElementInfo();	63	IBinaryMethod info = (IBinaryMethod) getElementInfo();
Lines 65-71 Link Here
65	if (defaultValue == null)	65	if (defaultValue == null)
66	return null;	66	return null;
67	MemberValuePair memberValuePair = new MemberValuePair(getElementName());	67	MemberValuePair memberValuePair = new MemberValuePair(getElementName());
68	memberValuePair.value = getMemberValue(memberValuePair, defaultValue);	68	memberValuePair.value = Util.getAnnotationMemberValue(this, memberValuePair, defaultValue);
69	return memberValuePair;	69	return memberValuePair;
70	}	70	}
71	/*	71	/*

Lines 182-188 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryType.java (-1 / +1 lines)
182	public IAnnotation[] getAnnotations() throws JavaModelException {	182	public IAnnotation[] getAnnotations() throws JavaModelException {
183	IBinaryType info = (IBinaryType) getElementInfo();	183	IBinaryType info = (IBinaryType) getElementInfo();
184	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();	184	IBinaryAnnotation[] binaryAnnotations = info.getAnnotations();
185	return getAnnotations(binaryAnnotations);	185	return getAnnotations(binaryAnnotations, info.getTagBits());
186	}	186	}
187	/*	187	/*
188	* @see IParent#getChildren()	188	* @see IParent#getChildren()

Lines 14-31 Link Here

(-)model/org/eclipse/jdt/internal/core/ClassFileInfo.java (-8 / +148 lines)
14	import java.util.HashMap;	14	import java.util.HashMap;
15		15
16	import org.eclipse.jdt.core.*;	16	import org.eclipse.jdt.core.*;
17	import org.eclipse.jdt.core.IClassFile;
18	import org.eclipse.jdt.core.IField;
19	import org.eclipse.jdt.core.IJavaElement;
20	import org.eclipse.jdt.core.IPackageFragment;
21	import org.eclipse.jdt.core.IType;
22	import org.eclipse.jdt.core.JavaModelException;
23	import org.eclipse.jdt.core.Signature;
24	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
		18	import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
		19	import org.eclipse.jdt.internal.compiler.env.IBinaryElementValuePair;
25	import org.eclipse.jdt.internal.compiler.env.IBinaryField;	20	import org.eclipse.jdt.internal.compiler.env.IBinaryField;
26	import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;	21	import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
27	import org.eclipse.jdt.internal.compiler.env.IBinaryNestedType;	22	import org.eclipse.jdt.internal.compiler.env.IBinaryNestedType;
28	import org.eclipse.jdt.internal.compiler.env.IBinaryType;	23	import org.eclipse.jdt.internal.compiler.env.IBinaryType;
		24	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
		25	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
29	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;	26	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
30		27
31	/**	28	/**
Lines 45-50 Link Here
45	protected ITypeParameter[] typeParameters;	42	protected ITypeParameter[] typeParameters;
46		43
47	/**	44	/**
		45	* Creates the handles and infos for the annotations of the given binary member.
		46	* Adds new handles to the given vector.
		47	*/
		48	private void generateAnnotationsInfos(BinaryMember member, IBinaryAnnotation[] binaryAnnotations, long tagBits, HashMap newElements) {
		49	if (binaryAnnotations != null) {
		50	for (int i = 0, length = binaryAnnotations.length; i < length; i++) {
		51	IBinaryAnnotation annotationInfo = binaryAnnotations[i];
		52	generateAnnotationInfo(member, newElements, annotationInfo);
		53	}
		54	}
		55	generateStandardAnnotationsInfos(member, tagBits, newElements);
		56	}
		57	private void generateAnnotationInfo(JavaElement parent, HashMap newElements, IBinaryAnnotation annotationInfo) {
		58	char[] typeName = org.eclipse.jdt.core.Signature.toCharArray(CharOperation.replaceOnCopy(annotationInfo.getTypeName(), '/', '.'));
		59	Annotation annotation = new Annotation(parent, new String(typeName));
		60	newElements.put(annotation, annotationInfo);
		61	IBinaryElementValuePair[] pairs = annotationInfo.getElementValuePairs();
		62	for (int i = 0, length = pairs.length; i < length; i++) {
		63	Object value = pairs[i].getValue();
		64	if (value instanceof IBinaryAnnotation) {
		65	generateAnnotationInfo(annotation, newElements, (IBinaryAnnotation) value);
		66	}
		67	}
		68	}
		69	private void generateStandardAnnotationsInfos(BinaryMember member, long tagBits, HashMap newElements) {
		70	if ((tagBits & TagBits.AllStandardAnnotationsMask) == 0)
		71	return;
		72	if ((tagBits & TagBits.AnnotationTargetMASK) != 0) {
		73	generateStandardAnnotation(member, TypeConstants.JAVA_LANG_ANNOTATION_TARGET, getTargetElementTypes(tagBits), newElements);
		74	}
		75	if ((tagBits & TagBits.AnnotationRetentionMASK) != 0) {
		76	generateStandardAnnotation(member, TypeConstants.JAVA_LANG_ANNOTATION_RETENTION, getRetentionPolicy(tagBits), newElements);
		77	}
		78	if ((tagBits & TagBits.AnnotationDeprecated) != 0) {
		79	generateStandardAnnotation(member, TypeConstants.JAVA_LANG_DEPRECATED, Annotation.NO_MEMBER_VALUE_PAIRS, newElements);
		80	}
		81	if ((tagBits & TagBits.AnnotationDocumented) != 0) {
		82	generateStandardAnnotation(member, TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED, Annotation.NO_MEMBER_VALUE_PAIRS, newElements);
		83	}
		84	if ((tagBits & TagBits.AnnotationInherited) != 0) {
		85	generateStandardAnnotation(member, TypeConstants.JAVA_LANG_ANNOTATION_INHERITED, Annotation.NO_MEMBER_VALUE_PAIRS, newElements);
		86	}
		87	// note that JAVA_LANG_SUPPRESSWARNINGS and JAVA_LANG_OVERRIDE cannot appear in binaries
		88	}
		89
		90	private void generateStandardAnnotation(BinaryMember member, char[][] typeName, IMemberValuePair[] members, HashMap newElements) {
		91	IAnnotation annotation = new Annotation(member, new String(CharOperation.concatWith(typeName, '.')));
		92	AnnotationInfo annotationInfo = new AnnotationInfo();
		93	annotationInfo.members = members;
		94	newElements.put(annotation, annotationInfo);
		95	}
		96
		97	private IMemberValuePair[] getTargetElementTypes(long tagBits) {
		98	ArrayList values = new ArrayList();
		99	String elementType = new String(CharOperation.concatWith(TypeConstants.JAVA_LANG_ANNOTATION_ELEMENTTYPE, '.')) + '.';
		100	if ((tagBits & TagBits.AnnotationForType) != 0) {
		101	values.add(elementType + new String(TypeConstants.TYPE));
		102	}
		103	if ((tagBits & TagBits.AnnotationForField) != 0) {
		104	values.add(elementType + new String(TypeConstants.UPPER_FIELD));
		105	}
		106	if ((tagBits & TagBits.AnnotationForMethod) != 0) {
		107	values.add(elementType + new String(TypeConstants.UPPER_METHOD));
		108	}
109	if ((tagBits & TagBits.AnnotationForParameter) != 0) {
110	values.add(elementType + new String(TypeConstants.UPPER_PARAMETER));
111	}
112	if ((tagBits & TagBits.AnnotationForConstructor) != 0) {
113	values.add(elementType + new String(TypeConstants.UPPER_CONSTRUCTOR));
114	}
115	if ((tagBits & TagBits.AnnotationForLocalVariable) != 0) {
116	values.add(elementType + new String(TypeConstants.UPPER_LOCAL_VARIABLE));
117	}
118	if ((tagBits & TagBits.AnnotationForAnnotationType) != 0) {
119	values.add(elementType + new String(TypeConstants.UPPER_ANNOTATION_TYPE));
120	}
121	if ((tagBits & TagBits.AnnotationForPackage) != 0) {
122	values.add(elementType + new String(TypeConstants.UPPER_PACKAGE));
123	}
124	final Object value;
125	if (values.size() == 0) {
126	if ((tagBits & TagBits.AnnotationTarget) != 0)
127	value = new String[0];
128	else
129	return Annotation.NO_MEMBER_VALUE_PAIRS;
130	} else if (values.size() == 1) {
131	value = values.get(0);
132	} else {
133	value = values.toArray(new String[values.size()]);
134	}
135	return new IMemberValuePair[] {
136	new IMemberValuePair() {
137	public int getValueKind() {
138	return IMemberValuePair.K_QUALIFIED_NAME;
139	}
140	public Object getValue() {
141	return value;
142	}
143	public String getMemberName() {
144	return new String(TypeConstants.VALUE);
145	}
146	}
147	};
148	}
149
150	private IMemberValuePair[] getRetentionPolicy(long tagBits) {
151	if ((tagBits & TagBits.AnnotationRetentionMASK) == 0)
152	return Annotation.NO_MEMBER_VALUE_PAIRS;
153	String retention = null;
154	if ((tagBits & TagBits.AnnotationClassRetention) != 0) {
155	retention = new String(CharOperation.concatWith(TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY, '.')) + '.' + new String(TypeConstants.UPPER_CLASS);
156	}
157	if ((tagBits & TagBits.AnnotationRuntimeRetention) != 0) {
158	retention = new String(CharOperation.concatWith(TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY, '.')) + '.' + new String(TypeConstants.UPPER_RUNTIME);
159	}
160	if ((tagBits & TagBits.AnnotationSourceRetention) != 0) {
161	retention = new String(CharOperation.concatWith(TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY, '.')) + '.' + new String(TypeConstants.UPPER_SOURCE);
162	}
163	final String value = retention;
164	return
165	new IMemberValuePair[] {
166	new IMemberValuePair() {
167	public int getValueKind() {
168	return IMemberValuePair.K_QUALIFIED_NAME;
169	}
170	public Object getValue() {
171	return value;
172	}
173	public String getMemberName() {
174	return new String(TypeConstants.VALUE);
175	}
176	}
177	};
178	}
179
180	/**
48	* Creates the handles and infos for the fields of the given binary type.	181	* Creates the handles and infos for the fields of the given binary type.
49	* Adds new handles to the given vector.	182	* Adds new handles to the given vector.
50	*/	183	*/
Lines 57-65 Link Here
57	JavaModelManager manager = JavaModelManager.getJavaModelManager();	190	JavaModelManager manager = JavaModelManager.getJavaModelManager();
58	for (int i = 0, fieldCount = fields.length; i < fieldCount; i++) {	191	for (int i = 0, fieldCount = fields.length; i < fieldCount; i++) {
59	IBinaryField fieldInfo = fields[i];	192	IBinaryField fieldInfo = fields[i];
60	IField field = new BinaryField((JavaElement)type, manager.intern(new String(fieldInfo.getName())));	193	BinaryField field = new BinaryField((JavaElement)type, manager.intern(new String(fieldInfo.getName())));
61	newElements.put(field, fieldInfo);	194	newElements.put(field, fieldInfo);
62	childrenHandles.add(field);	195	childrenHandles.add(field);
		196	generateAnnotationsInfos(field, fieldInfo.getAnnotations(), fieldInfo.getTagBits(), newElements);
63	}	197	}
64	}	198	}
65	/**	199	/**
Lines 131-136 Link Here
131	newElements.put(method, methodInfo);	265	newElements.put(method, methodInfo);
132		266
133	generateTypeParameterInfos(method, signature, newElements, typeParameterHandles);	267	generateTypeParameterInfos(method, signature, newElements, typeParameterHandles);
		268	generateAnnotationsInfos(method, methodInfo.getAnnotations(), methodInfo.getTagBits(), newElements);
		269	Object defaultValue = methodInfo.getDefaultValue();
		270	if (defaultValue instanceof IBinaryAnnotation) {
		271	generateAnnotationInfo(method, newElements, (IBinaryAnnotation) defaultValue);
		272	}
134	}	273	}
135	}	274	}
136	/**	275	/**
Lines 180-185 Link Here
180	BinaryType type = (BinaryType) classFile.getType();	319	BinaryType type = (BinaryType) classFile.getType();
181	ArrayList typeParameterHandles = new ArrayList();	320	ArrayList typeParameterHandles = new ArrayList();
182	if (typeInfo != null) { //may not be a valid class file	321	if (typeInfo != null) { //may not be a valid class file
		322	generateAnnotationsInfos(type, typeInfo.getAnnotations(), typeInfo.getTagBits(), newElements);
183	generateTypeParameterInfos(type, typeInfo.getGenericSignature(), newElements, typeParameterHandles);	323	generateTypeParameterInfos(type, typeInfo.getGenericSignature(), newElements, typeParameterHandles);
184	generateFieldInfos(type, typeInfo, newElements, childrenHandles);	324	generateFieldInfos(type, typeInfo, newElements, childrenHandles);
185	generateMethodInfos(type, typeInfo, newElements, childrenHandles, typeParameterHandles);	325	generateMethodInfos(type, typeInfo, newElements, childrenHandles, typeParameterHandles);

Lines 15-20 Link Here

(-)dom/org/eclipse/jdt/core/dom/AnnotationBinding.java (+4 lines)
15	import org.eclipse.jdt.core.IAnnotatable;	15	import org.eclipse.jdt.core.IAnnotatable;
16	import org.eclipse.jdt.core.ICompilationUnit;	16	import org.eclipse.jdt.core.ICompilationUnit;
17	import org.eclipse.jdt.core.IJavaElement;	17	import org.eclipse.jdt.core.IJavaElement;
		18	import org.eclipse.jdt.core.IMember;
18	import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;	19	import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
19	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;	20	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
20	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;	21	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
Lines 132-137 Link Here
132	return null;	133	return null;
133	}	134	}
134	if (! (parentElement instanceof IAnnotatable)) return null;	135	if (! (parentElement instanceof IAnnotatable)) return null;
		136	if ((parentElement instanceof IMember) && ((IMember) parentElement).isBinary()) {
		137	return ((IAnnotatable) parentElement).getAnnotation(getAnnotationType().getQualifiedName());
		138	}
135	return ((IAnnotatable) parentElement).getAnnotation(getName());	139	return ((IAnnotatable) parentElement).getAnnotation(getName());
136	}	140	}
137		141

Lines 45-50 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (+48 lines)
45	import org.eclipse.jdt.internal.compiler.ast.TypeReference;	45	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
46	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;	46	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
47	import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;	47	import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
		48	import org.eclipse.jdt.internal.compiler.env.ClassSignature;
		49	import org.eclipse.jdt.internal.compiler.env.EnumConstantSignature;
		50	import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
48	import org.eclipse.jdt.internal.compiler.env.IDependent;	51	import org.eclipse.jdt.internal.compiler.env.IDependent;
49	import org.eclipse.jdt.internal.compiler.impl.Constant;	52	import org.eclipse.jdt.internal.compiler.impl.Constant;
50	import org.eclipse.jdt.internal.compiler.lookup.Binding;	53	import org.eclipse.jdt.internal.compiler.lookup.Binding;
Lines 55-60 Link Here
55	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	58	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
56	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	59	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
57	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;	60	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
		61	import org.eclipse.jdt.internal.core.Annotation;
58	import org.eclipse.jdt.internal.core.ClassFile;	62	import org.eclipse.jdt.internal.core.ClassFile;
59	import org.eclipse.jdt.internal.core.JavaElement;	63	import org.eclipse.jdt.internal.core.JavaElement;
60	import org.eclipse.jdt.internal.core.JavaModelManager;	64	import org.eclipse.jdt.internal.core.JavaModelManager;
Lines 3061-3066 Link Here
3061	}	3065	}
3062	return typeArguments;	3066	return typeArguments;
3063	}	3067	}
		3068	public static IAnnotation getAnnotation(JavaElement parent, IBinaryAnnotation binaryAnnotation) {
		3069	char[] typeName = org.eclipse.jdt.core.Signature.toCharArray(CharOperation.replaceOnCopy(binaryAnnotation.getTypeName(), '/', '.'));
		3070	return new Annotation(parent, new String(typeName));
		3071	}
		3072
		3073	public static Object getAnnotationMemberValue(JavaElement parent, MemberValuePair memberValuePair, Object binaryValue) {
		3074	if (binaryValue instanceof Constant) {
		3075	return getAnnotationMemberValue(memberValuePair, (Constant) binaryValue);
		3076	} else if (binaryValue instanceof IBinaryAnnotation) {
		3077	memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
		3078	return getAnnotation(parent, (IBinaryAnnotation) binaryValue);
		3079	} else if (binaryValue instanceof ClassSignature) {
		3080	memberValuePair.valueKind = IMemberValuePair.K_CLASS;
		3081	char[] className = Signature.toCharArray(CharOperation.replaceOnCopy(((ClassSignature) binaryValue).getTypeName(), '/', '.'));
		3082	return new String(className);
		3083	} else if (binaryValue instanceof EnumConstantSignature) {
		3084	memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
		3085	EnumConstantSignature enumConstant = (EnumConstantSignature) binaryValue;
		3086	char[] enumName = Signature.toCharArray(CharOperation.replaceOnCopy(enumConstant.getTypeName(), '/', '.'));
		3087	char[] qualifiedName = CharOperation.concat(enumName, enumConstant.getEnumConstantName(), '.');
		3088	return new String(qualifiedName);
		3089	} else if (binaryValue instanceof Object[]) {
		3090	memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
		3091	Object[] binaryValues = (Object[]) binaryValue;
		3092	int length = binaryValues.length;
		3093	Object[] values = new Object[length];
		3094	for (int i = 0; i < length; i++) {
		3095	int previousValueKind = memberValuePair.valueKind;
		3096	Object value = getAnnotationMemberValue(parent, memberValuePair, binaryValues[i]);
		3097	if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
		3098	// values are heterogeneous, value kind is thus unknown
		3099	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
		3100	}
		3101	values[i] = value;
		3102	}
		3103	if (memberValuePair.valueKind == -1)
		3104	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
		3105	return values;
		3106	} else {
		3107	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
		3108	return null;
		3109	}
		3110	}
		3111
3064	/*	3112	/*
3065	* Creates a member value from the given constant, and sets the valueKind on the given memberValuePair	3113	* Creates a member value from the given constant, and sets the valueKind on the given memberValuePair
3066	*/	3114	*/

Lines 5354-5364 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTest2.java (-5 / +1 lines)
5354	"}",	5354	"}",
5355	}, "1.5");	5355	}, "1.5");
5356	IClassFile classFile = getClassFile("P1", "/P1/lib.jar", "p", "X$Member.class");	5356	IClassFile classFile = getClassFile("P1", "/P1/lib.jar", "p", "X$Member.class");
5357	String source = classFile.getSource();	5357	ASTNode node = buildAST(classFile);
5358	MarkerInfo markerInfo = new MarkerInfo(source);
5359	markerInfo.astStarts = new int[] {source.indexOf("/start/") + "/start/".length()};
5360	markerInfo.astEnds = new int[] {source.indexOf("/end/")};
5361	ASTNode node = buildAST(markerInfo, classFile);
5362	ITypeBinding binding = ((TypeDeclaration) node).resolveBinding();	5358	ITypeBinding binding = ((TypeDeclaration) node).resolveBinding();
5363	assertBindingKeyEquals("Lp/X<TT;>.Member;", binding.getKey());	5359	assertBindingKeyEquals("Lp/X<TT;>.Member;", binding.getKey());
5364	} finally {	5360	} finally {

Lines 709-714 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/AbstractASTTests.java (+9 lines)
709	return result;	709	return result;
710	}	710	}
711		711
		712	protected ASTNode buildAST(IClassFile classFile) throws JavaModelException {
		713	String source = classFile.getSource();
		714	MarkerInfo markerInfo = new MarkerInfo(source);
		715	markerInfo.astStarts = new int[] {source.indexOf("/start/") + "/start/".length()};
		716	markerInfo.astEnds = new int[] {source.indexOf("/end/")};
		717	ASTNode node = buildAST(markerInfo, classFile);
		718	return node;
		719	}
		720
712		721
713	// protected void tearDown() throws Exception {	722	// protected void tearDown() throws Exception {
714	// discardWorkingCopies(this.workingCopies);	723	// discardWorkingCopies(this.workingCopies);




				"  void foo() {\n" +
				"    new Member() {};\n" +
				"  }\n" +
				"}",
				"p/Q.java",
				"package p;\n" +
				"/*start*/@MyAnnot/*end*/\n" +
				"public class Q {\n" +
				"}\n" +
				"@interface MyAnnot {\n" +
				"}",
			},
			"1.5");
		setUpWorkingCopy();

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in field [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			);
			IBinding binding = ((Annotation) node).resolveAnnotationBinding();
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"@MyAnnot [in package pkg [in [Working copy] package-info.java [in pkg [in src [in P]]]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			if (myAnnot != null)
				myAnnot.discardWorkingCopy();

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in var1 [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element

		);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@MyAnnot [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
	}
	
	/*
	 * Ensures that the IJavaElement of an IBinding representing an annotation of a binary member type is correct.
	 */
	public void testAnnotation8() throws Exception {
		IClassFile classFile = getClassFile("P", "/P/lib.jar", "p", "Q.class");
		ASTNode node = buildAST(classFile);
		IBinding binding = ((Annotation) node).resolveAnnotationBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"@p.MyAnnot [in Q [in Q.class [in p [in lib.jar [in P]]]]]",
			element
		);
	}

	/*
	 * Ensures that the IJavaElement of an IBinding representing an anonymous type is correct.

			"}"
		);
		IBinding binding = ((AnonymousClassDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<anonymous #1> [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	public void testAnonymousType2() throws JavaModelException {

			"}"
		);
		IBinding binding = ((AnonymousClassDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<anonymous #1> [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((ArrayType) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Object [in Object.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((ArrayType) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<null>",
			element

		markerInfo.astEnds = new int[] {source.indexOf('}', markerInfo.astStarts[0]) + 1};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Enum(java.lang.String, int) [in Enum [in Enum.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

	 */
	public void testBinaryMemberTypeConstructor() throws JavaModelException {
		IClassFile classFile = getClassFile("P", "/P/lib.jar", "p", "W$Member.class");
		ASTNode node = buildAST(classFile);
		MarkerInfo markerInfo = new MarkerInfo(source);
		markerInfo.astStarts = new int[] {source.indexOf("/*start*/") + "/*start*/".length()};
		markerInfo.astEnds = new int[] {source.indexOf("/*end*/")};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Member(p.W, java.lang.String) [in Member [in W$Member.class [in p [in lib.jar [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

		markerInfo.astEnds = new int[] {source.lastIndexOf('}') + 1};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

		markerInfo.astEnds = new int[] {source.lastIndexOf('}') + 1};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"ABC [in ABC.class [in p [in lib.jar [in P]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			ASTNode node = buildAST(getCompilationUnit("/P1/X.java"));
			IBinding binding = ((Type) node).resolveBinding();
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			deleteProject("P1");
			setUpJavaProject();

	 */
	public void testBinaryMemberTypeFromAnonymousClassFile1() throws JavaModelException {
		IClassFile classFile = getClassFile("P", "/P/lib.jar", "p", "Z$1.class");
		ASTNode node = buildAST(classFile);
		MarkerInfo markerInfo = new MarkerInfo(source);
		markerInfo.astStarts = new int[] {source.indexOf("/*start*/") + "/*start*/".length()};
		markerInfo.astEnds = new int[] {source.indexOf("/*end*/")};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Member [in Z$Member.class [in p [in lib.jar [in P]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

	 */
	public void testBinaryMemberTypeFromAnonymousClassFile2() throws JavaModelException {
		IClassFile classFile = getClassFile("P", "/P/lib.jar", "", "Z$1.class");
		ASTNode node = buildAST(classFile);
		MarkerInfo markerInfo = new MarkerInfo(source);
		markerInfo.astStarts = new int[] {source.indexOf("/*start*/") + "/*start*/".length()};
		markerInfo.astEnds = new int[] {source.indexOf("/*end*/")};
		ASTNode node = buildAST(markerInfo, classFile);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Member [in Z$Member.class [in <default> [in lib.jar [in P]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}",
			getClassFile("/P/lib/A.class").getType().getMethod("foo", new String[] {"Ljava.lang.String;"})
		);
		assertNotNull("No bindings", bindings);
		assertEquals("Wrong size", 1, bindings.length);
		assertTrue("Not a method binding", bindings[0] instanceof IMethodBinding);
		assertBindingsEqual(
			"LA;.foo(Ljava/lang/String;)Ljava/lang/String;",
			bindings);

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"field [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"field [in <anonymous #1> [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((TypeDeclarationStatement) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Y [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*


			// Ensure the Java element is correct
			IJavaElement element = bindings[0].getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"Local [in foo() [in Z [in Z.java [in <default> [in src [in P]]]]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			deleteFile(filePath);
		}

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		IJavaElement expected = getLocalVariable(this.workingCopy, "local", "local");
		assertEquals(

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		IJavaElement expected = getLocalVariable(this.workingCopy, "second", "second");
		assertEquals(

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		IJavaElement expected = getLocalVariable(this.workingCopy, "arg", "arg");
		assertEquals(

			"}"
		);
		IBinding binding = ((VariableDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		IJavaElement expected = getLocalVariable(this.workingCopy, "local", "local");
		assertEquals(

			"}"
		);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementEquals(
			"Unexpected Java element",

			"}"
		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"foo(int, Object, java.lang.String, Class[], X<K,V>) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

				"}"
			);
			IBinding binding = ((MethodInvocation) node).resolveMethodBinding();
			assertNotNull("No binding", binding);
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"foo(int, String[], java.lang.Class) [in Y [in [Working copy] Y.java [in <default> [in src [in P]]]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			if (otherWorkingCopy != null)
				otherWorkingCopy.discardWorkingCopy();

			"}"
		);
		IBinding binding = ((MethodInvocation) node).resolveMethodBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"bar(A<? extends T>) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((MethodInvocation) node).resolveMethodBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"m(T) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((SimpleName) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"value() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"bar(int[]) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"bar2(Object[][][]) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"bar3(Object[]) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*


			ASTNode node = buildAST(null/*use existing contents*/, cu, false/*don't report errors*/, true/*statement recovery*/, false);
			IBinding binding = ((MethodDeclaration) node).resolveBinding();
			assertNotNull("No binding", binding);
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"yes() [in <anonymous #1> [in test() [in X [in Test.java [in <default> [in src [in P]]]]]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			deleteFile("/P/src/Test.java");
		}

		);
		IBinding binding = ((MethodDeclaration) node).resolveBinding();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"bar() [in <anonymous #1> [in <initializer #1> [in <anonymous #1> [in foo() [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]]]]]",
			element

			);
			IBinding binding = ((MethodDeclaration) node).resolveBinding();
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"foo(p2.X249567) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
				element

			);
			IBinding binding = ((MethodDeclaration) node).resolveBinding();
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"foo(p1.X249567.Member) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
				element

			);
			IBinding binding = ((MethodDeclaration) node).resolveBinding();
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"foo(p1.X249567.Member<java.lang.String>) [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
				element

			"}"
		);
		IBinding binding = ((QualifiedName) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"java.lang [in "+ getExternalJCLPathString("1.5") + "]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}/*end*/"
		);
		ITypeBinding typeBinding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", typeBinding);
		IPackageBinding binding = typeBinding.getPackage();
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<default> [in src [in P]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((Type) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Comparable [in Comparable.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((SuperConstructorInvocation) node).resolveConstructorBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Y(T) [in Y [in Y.class [in p [in lib.jar [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((Type) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"Comparable [in Comparable.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}/*end*/"
		);
		IBinding binding = ((TypeDeclaration) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"X [in [Working copy] X.java [in <default> [in src [in P]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

				"}"
			);
			IBinding binding = ((Type) node).resolveBinding();
			assertNotNull("No binding", binding);
			IJavaElement element = binding.getJavaElement();
			assertElementExists(
				"Unexpected Java element",
				"Y [in Y.java [in <default> [in src [in P]]]]",
				element
			);
			assertTrue("Element should exist", element.exists());
		} finally {
			deleteFile("/P/src/Y.java");
		}

			"}"
		);
		IBinding binding = ((Type) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((TypeParameter) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<T> [in X [in [Working copy] X.java [in <default> [in src [in P]]]]]",
			element
		);
		assertTrue("Element should exist", element.exists());
	}

	/*

			"}"
		);
		IBinding binding = ((WildcardType) node).resolveBinding();
		assertNotNull("No binding", binding);
		IJavaElement element = binding.getJavaElement();
		assertElementExists(
			"Unexpected Java element",
			"<null>",
			element

Lines 300-307 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavadocPackageCompletionModelTest.java (-2 / +3 lines)
300	"package javadoc.tags;\n";	300	"package javadoc.tags;\n";
301	completeInJavadoc("/Completion/src/javadoc/tags/package-info.java", source, true, "I");	301	completeInJavadoc("/Completion/src/javadoc/tags/package-info.java", source, true, "I");
302	assertSortedResults(	302	assertSortedResults(
303	"IllegalMonitorStateException[TYPE_REF]{IllegalMonitorStateException, java.lang, Ljava.lang.IllegalMonitorStateException;, null, null, "+this.positions+R_DRICUNR+"}\n" +	303	"IllegalMonitorStateException[TYPE_REF]{IllegalMonitorStateException, java.lang, Ljava.lang.IllegalMonitorStateException;, null, null, "+this.positions+R_DRICUNR+"}\n" +
304	"InterruptedException[TYPE_REF]{InterruptedException, java.lang, Ljava.lang.InterruptedException;, null, null, "+this.positions+R_DRICUNR+"}\n" +	304	"InterruptedException[TYPE_REF]{InterruptedException, java.lang, Ljava.lang.InterruptedException;, null, null, "+this.positions+R_DRICUNR+"}\n" +
		305	"Inherited[TYPE_REF]{java.lang.annotation.Inherited, java.lang.annotation, Ljava.lang.annotation.Inherited;, null, null, "+this.positions+R_DRICNR+"}\n" +
305	"Iterator[TYPE_REF]{java.util.Iterator, java.util, Ljava.util.Iterator;, null, null, "+this.positions+R_DRICNR+"}"	306	"Iterator[TYPE_REF]{java.util.Iterator, java.util, Ljava.util.Iterator;, null, null, "+this.positions+R_DRICNR+"}"
306	);	307	);
307	}	308	}




	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
	String source = classFile.getSource();
	IJavaElement element = classFile.getElementAt(source.indexOf("class A"));
	assertElementExists(
		"Unexpected element",
		"A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]",
		element);

	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
	String source = classFile.getSource();
	IJavaElement element = classFile.getElementAt(source.indexOf("public A"));
	assertElementExists(
		"Unexpected element",
		"A() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",
		element);

	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
	String source = classFile.getSource();
	IJavaElement element = classFile.getElementAt(source.indexOf("void foo"));
	assertElementExists(
		"Unexpected element",
		"foo() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",
		element);

	IClassFile classFile = this.innerClasses.getClassFile("X$V.class");
	String source = classFile.getSource();
	IJavaElement element = classFile.getElementAt(source.indexOf("V(String s)"));
	assertElementExists(
		"Unexpected element",
		"V(inner.X, java.lang.String) [in V [in X$V.class [in inner [in innerClasses.jar [in AttachSourceTests]]]]]",
		element);




	search("Ax", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
// TODO: reenable after assessing whether the reference in java.lang.Deprecated is expected
public void _testBug110060_TypePattern06() throws CoreException {
	setUpBug110060_TypePattern();
	search("A*A*", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
// TODO: reenable after assessing whether the reference in java.lang.Deprecated is expected
public void _testBug110060_TypePattern06_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("A*A*", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)




import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.core.tests.junit.extension.TestCase;
import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;


	}
	protected void addExternalLibrary(IJavaProject javaProject, String jarPath, String[] pathAndContents, String[] nonJavaResources, String compliance) throws Exception {
		String[] claspath = get15LibraryIfNeeded(compliance);
		org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, claspath, compliance);
		addLibraryEntry(javaProject, new Path(jarPath), true/*exported*/);
	}
	protected void addLibrary(String jarName, String sourceZipName, String[] pathAndContents, String compliance) throws CoreException, IOException {

		IProject project = javaProject.getProject();
		String projectLocation = project.getLocation().toOSString();
		String jarPath = projectLocation + File.separator + jarName;
		String[] claspath = get15LibraryIfNeeded(compliance);
		org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, claspath, compliance);
		if (pathAndContents != null && pathAndContents.length != 0) {
			String sourceZipPath = projectLocation + File.separator + sourceZipName;
			org.eclipse.jdt.core.tests.util.Util.createSourceZip(pathAndContents, sourceZipPath);

		}
		assertEquals(message, expected, actual);
	}
	protected void assertElementExists(String message, String expected, IJavaElement element) {
		assertElementEquals(message, expected, element);
		if (element != null && !element.exists()) {
			fail(((JavaElement) element).toStringWithAncestors(false/*don't show key*/) + " doesn't exist");
		}
	}
	protected void assertElementsEqual(String message, String expected, IJavaElement[] elements) {
		assertElementsEqual(message, expected, elements, false/*don't show key*/);
	}

			assertTrue("Did not find sibling", found);
		}
	}
	protected String[] get15LibraryIfNeeded(String compliance) throws JavaModelException, IOException {
		if (compliance.charAt(compliance.length()-1) >= '5' && (AbstractCompilerTest.getPossibleComplianceLevels() & AbstractCompilerTest.F_1_5) == 0) {
			// ensure that the JCL 15 lib is setup (i.e. that the jclMin15.jar is copied)
			setUpJCLClasspathVariables("1.5");
			return new String[] {getExternalJCLPathString("1.5")};
		}
		return null;
	}
	/**
	 * Returns the specified compilation unit in the given project, root, and
	 * package fragment or <code>null</code> if it does not exist.




import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;

import junit.framework.Test;


		"enum MyEnum {\n" +
		"  FIRST, SECOND;\n" +
		"}",
		"annotated/Y.java",
		"package annotated;\n" +
		"import java.lang.annotation.*;\n" +
		"import static java.lang.annotation.ElementType.*;\n" + 
		"import static java.lang.annotation.RetentionPolicy.*;\n" + 
		"@Deprecated\n" +
		"@Documented\n" + 
		"@Inherited\n" +
		"@Retention(SOURCE)\n" + 
		"@Target({PACKAGE, TYPE, ANNOTATION_TYPE, METHOD, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PARAMETER})\n" +
		"public @interface Y {\n" +
		"}",
		"varargs/X.java",
		"package varargs;\n" +
		"public class X {\n" +

		"  }\n" +
		"}",
	};
	if ((AbstractCompilerTest.getPossibleComplianceLevels() & AbstractCompilerTest.F_1_5) == 0) {
		int length = pathAndContents.length;
		System.arraycopy(pathAndContents, 0, pathAndContents = new String[length+4], 0, length);
		pathAndContents[length] = "java/lang/annotation/Annotation.java";
		pathAndContents[length+1] =
			"package java.lang.annotation;\n" +
			"public interface Annotation {\n" +
			"}";
		pathAndContents[length+2] = "java/lang/Enum.java";
		pathAndContents[length+3] =
			"package java.lang;\n" +
			"public abstract class Enum<E extends Enum<E>> {\n" +
			"  protected Enum(String arg1, int arg2) {\n" +
			"  }\n" +
			"}";
	}
	addLibrary(javaProject, "lib.jar", "libsrc.zip", pathAndContents, JavaCore.VERSION_1_5);
	this.jarRoot = javaProject.getPackageFragmentRoot(getFile("/P/lib.jar"));
}

}

/*
 * Ensures that the standard annotations of a binary type are correct
 * (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=248309 )
 */
public void testAnnotations17() throws JavaModelException {
	IType type = this.jarRoot.getPackageFragment("annotated").getClassFile("Y.class").getType();
	assertAnnotationsEqual(
		"@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.PACKAGE})\n" + 
		"@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)\n" + 
		"@java.lang.Deprecated\n" + 
		"@java.lang.annotation.Documented\n" + 
		"@java.lang.annotation.Inherited\n",
		type.getAnnotations());
}

/*
 * Ensures that the annotation of a binary type exists
 */
public void testAnnotations18() throws JavaModelException {
	IAnnotation annotation = this.jarRoot.getPackageFragment("annotated").getClassFile("X.class").getType().getAnnotation("annotated.MyOtherAnnot");
	assertTrue("Annotation should exist", annotation.exists());
}

/*
 * Ensures that no exception is thrown for a .class file name with a dot
 * (regression test for bug 114140 assertion failed when opening a class file not not the classpath)
 */

Lines 168-175 Link Here

(-)src/org/eclipse/jdt/core/tests/util/Util.java (-3 / +6 lines)
168	if (classpath != null) {	168	if (classpath != null) {
169	int length = classpath.length;	169	int length = classpath.length;
170	int classLibsLength = classLibs.length;	170	int classLibsLength = classLibs.length;
171	System.arraycopy(classpath, 0, classpath = new String[classLibsLength + length], classLibsLength, length);	171	System.arraycopy(classpath, 0, classpath = new String[length + classLibsLength], 0, length);
172	System.arraycopy(classLibs, 0, classpath, 0, classLibsLength);	172	System.arraycopy(classLibs, 0, classpath, length, classLibsLength);
173	} else {	173	} else {
174	classpath = classLibs;	174	classpath = classLibs;
175	}	175	}
Lines 355-361 Link Here
355	createJar(javaPathsAndContents, null, jarPath, compliance);	355	createJar(javaPathsAndContents, null, jarPath, compliance);
356	}	356	}
357	public static void createJar(String[] javaPathsAndContents, String[] extraPathsAndContents, String jarPath, String compliance) throws IOException {	357	public static void createJar(String[] javaPathsAndContents, String[] extraPathsAndContents, String jarPath, String compliance) throws IOException {
358	createJar(javaPathsAndContents, extraPathsAndContents, getCompileOptions(compliance), null, jarPath);	358	createJar(javaPathsAndContents, extraPathsAndContents, jarPath, null/no classpath/, compliance);
		359	}
		360	public static void createJar(String[] javaPathsAndContents, String[] extraPathsAndContents, String jarPath, String[] classpath, String compliance) throws IOException {
		361	createJar(javaPathsAndContents, extraPathsAndContents, getCompileOptions(compliance), classpath, jarPath);
359	}	362	}
360	public static void createSourceZip(String[] pathsAndContents, String zipPath) throws IOException {	363	public static void createSourceZip(String[] pathsAndContents, String zipPath) throws IOException {
361	String sourcesPath = getOutputDirectory() + File.separator + "sources";	364	String sourcesPath = getOutputDirectory() + File.separator + "sources";

Return to bug 248309

Lines 4990-4996 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (-2 / +4 lines)
4990	search("Ax", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);	4990	search("Ax", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
4991	assertSearchResults("");	4991	assertSearchResults("");
4992	}	4992	}
4993	public void testBug110060_TypePattern06() throws CoreException {	4993	// TODO: reenable after assessing whether the reference in java.lang.Deprecated is expected
		4994	public void _testBug110060_TypePattern06() throws CoreException {
4994	setUpBug110060_TypePattern();	4995	setUpBug110060_TypePattern();
4995	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);	4996	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
4996	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)	4997	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
Lines 5003-5009 Link Here
5003	"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"	5004	"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
5004	);	5005	);
5005	}	5006	}
5006	public void testBug110060_TypePattern06_SamePartCount() throws CoreException {	5007	// TODO: reenable after assessing whether the reference in java.lang.Deprecated is expected
		5008	public void _testBug110060_TypePattern06_SamePartCount() throws CoreException {
5007	setUpBug110060_TypePattern();	5009	setUpBug110060_TypePattern();
5008	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);	5010	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
5009	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)	5011	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)

Lines 27-32 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (-2 / +19 lines)
27	import org.eclipse.jdt.core.dom.CompilationUnit;	27	import org.eclipse.jdt.core.dom.CompilationUnit;
28	import org.eclipse.jdt.core.search.*;	28	import org.eclipse.jdt.core.search.*;
29	import org.eclipse.jdt.core.tests.junit.extension.TestCase;	29	import org.eclipse.jdt.core.tests.junit.extension.TestCase;
		30	import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
30	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	31	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
31	import org.eclipse.jdt.internal.core.ClasspathEntry;	32	import org.eclipse.jdt.internal.core.ClasspathEntry;
32	import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;	33	import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;
Lines 392-398 Link Here
392		393
393	}	394	}
394	protected void addExternalLibrary(IJavaProject javaProject, String jarPath, String[] pathAndContents, String[] nonJavaResources, String compliance) throws Exception {	395	protected void addExternalLibrary(IJavaProject javaProject, String jarPath, String[] pathAndContents, String[] nonJavaResources, String compliance) throws Exception {
395	org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, compliance);	396	String[] claspath = get15LibraryIfNeeded(compliance);
		397	org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, claspath, compliance);
396	addLibraryEntry(javaProject, new Path(jarPath), true/exported/);	398	addLibraryEntry(javaProject, new Path(jarPath), true/exported/);
397	}	399	}
398	protected void addLibrary(String jarName, String sourceZipName, String[] pathAndContents, String compliance) throws CoreException, IOException {	400	protected void addLibrary(String jarName, String sourceZipName, String[] pathAndContents, String compliance) throws CoreException, IOException {
Lines 422-428 Link Here
422	IProject project = javaProject.getProject();	424	IProject project = javaProject.getProject();
423	String projectLocation = project.getLocation().toOSString();	425	String projectLocation = project.getLocation().toOSString();
424	String jarPath = projectLocation + File.separator + jarName;	426	String jarPath = projectLocation + File.separator + jarName;
425	org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, compliance);	427	String[] claspath = get15LibraryIfNeeded(compliance);
		428	org.eclipse.jdt.core.tests.util.Util.createJar(pathAndContents, nonJavaResources, jarPath, claspath, compliance);
426	if (pathAndContents != null && pathAndContents.length != 0) {	429	if (pathAndContents != null && pathAndContents.length != 0) {
427	String sourceZipPath = projectLocation + File.separator + sourceZipName;	430	String sourceZipPath = projectLocation + File.separator + sourceZipName;
428	org.eclipse.jdt.core.tests.util.Util.createSourceZip(pathAndContents, sourceZipPath);	431	org.eclipse.jdt.core.tests.util.Util.createSourceZip(pathAndContents, sourceZipPath);
Lines 597-602 Link Here
597	}	600	}
598	assertEquals(message, expected, actual);	601	assertEquals(message, expected, actual);
599	}	602	}
		603	protected void assertElementExists(String message, String expected, IJavaElement element) {
		604	assertElementEquals(message, expected, element);
		605	if (element != null && !element.exists()) {
		606	fail(((JavaElement) element).toStringWithAncestors(false/don't show key/) + " doesn't exist");
		607	}
		608	}
600	protected void assertElementsEqual(String message, String expected, IJavaElement[] elements) {	609	protected void assertElementsEqual(String message, String expected, IJavaElement[] elements) {
601	assertElementsEqual(message, expected, elements, false/don't show key/);	610	assertElementsEqual(message, expected, elements, false/don't show key/);
602	}	611	}
Lines 1698-1703 Link Here
1698	assertTrue("Did not find sibling", found);	1707	assertTrue("Did not find sibling", found);
1699	}	1708	}
1700	}	1709	}
		1710	protected String[] get15LibraryIfNeeded(String compliance) throws JavaModelException, IOException {
		1711	if (compliance.charAt(compliance.length()-1) >= '5' && (AbstractCompilerTest.getPossibleComplianceLevels() & AbstractCompilerTest.F_1_5) == 0) {
		1712	// ensure that the JCL 15 lib is setup (i.e. that the jclMin15.jar is copied)
		1713	setUpJCLClasspathVariables("1.5");
		1714	return new String[] {getExternalJCLPathString("1.5")};
		1715	}
		1716	return null;
		1717	}
1701	/**	1718	/**
1702	* Returns the specified compilation unit in the given project, root, and	1719	* Returns the specified compilation unit in the given project, root, and
1703	* package fragment or <code>null</code> if it does not exist.	1720	* package fragment or <code>null</code> if it does not exist.

Lines 10-35 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryMember.java (-67 / +36 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core;	11	package org.eclipse.jdt.internal.core;
12		12
		13	import java.util.ArrayList;
		14
13	import org.eclipse.core.runtime.IProgressMonitor;	15	import org.eclipse.core.runtime.IProgressMonitor;
14	import org.eclipse.jdt.core.IAnnotation;	16	import org.eclipse.jdt.core.IAnnotation;
15	import org.eclipse.jdt.core.IJavaElement;	17	import org.eclipse.jdt.core.IJavaElement;
16	import org.eclipse.jdt.core.IJavaModelStatusConstants;	18	import org.eclipse.jdt.core.IJavaModelStatusConstants;
17	import org.eclipse.jdt.core.IMemberValuePair;
18	import org.eclipse.jdt.core.ISourceRange;	19	import org.eclipse.jdt.core.ISourceRange;
19	import org.eclipse.jdt.core.JavaModelException;	20	import org.eclipse.jdt.core.JavaModelException;
20	import org.eclipse.jdt.core.Signature;
21	import org.eclipse.jdt.core.compiler.CharOperation;	21	import org.eclipse.jdt.core.compiler.CharOperation;
22	import org.eclipse.jdt.internal.compiler.env.ClassSignature;
23	import org.eclipse.jdt.internal.compiler.env.EnumConstantSignature;
24	import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;	22	import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
25	import org.eclipse.jdt.internal.compiler.env.IBinaryElementValuePair;	23	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
26	import org.eclipse.jdt.internal.compiler.impl.Constant;	24	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
27	import org.eclipse.jdt.internal.core.util.Util;	25	import org.eclipse.jdt.internal.core.util.Util;
28		26
29	/**	27	/**
30	* Common functionality for Binary member handles.	28	* Common functionality for Binary member handles.
31	*/	29	*/
32	public abstract class BinaryMember extends NamedMember {	30	public abstract class BinaryMember extends NamedMember {
		31
33	/*	32	/*
34	* Constructs a binary member.	33	* Constructs a binary member.
35	*/	34	*/
Lines 42-117 Link Here
42	public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {	41	public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
43	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));	42	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
44	}	43	}
45	protected IAnnotation[] getAnnotations(IBinaryAnnotation[] binaryAnnotations) {	44	protected IAnnotation[] getAnnotations(IBinaryAnnotation[] binaryAnnotations, long tagBits) {
		45	IAnnotation[] standardAnnotations = getStandardAnnotations(tagBits);
46	if (binaryAnnotations == null)	46	if (binaryAnnotations == null)
47	return Annotation.NO_ANNOTATIONS;	47	return standardAnnotations;
48	int length = binaryAnnotations.length;	48	int length = binaryAnnotations.length;
49	IAnnotation[] annotations = new IAnnotation[length];	49	int standardLength = standardAnnotations.length;
		50	IAnnotation[] annotations = new IAnnotation[length + standardLength];
50	for (int i = 0; i < length; i++) {	51	for (int i = 0; i < length; i++) {
51	annotations[i] = getAnnotation(binaryAnnotations[i]);	52	annotations[i] = Util.getAnnotation(this, binaryAnnotations[i]);
52	}	53	}
		54	System.arraycopy(standardAnnotations, 0, annotations, length, standardLength);
53	return annotations;	55	return annotations;
54	}	56	}
55	private IAnnotation getAnnotation(IBinaryAnnotation binaryAnnotation) {	57	private IAnnotation getAnnotation(char[][] annotationName) {
56	IBinaryElementValuePair[] binaryElementValuePairs = binaryAnnotation.getElementValuePairs();	58	return new Annotation(this, new String(CharOperation.concatWith(annotationName, '.')));
57	int pairsLength = binaryElementValuePairs.length;
58	final IMemberValuePair[] members;
59	if (pairsLength == 0) {
60	members = Annotation.NO_MEMBER_VALUE_PAIRS;
61	} else {
62	members = new IMemberValuePair[pairsLength];
63	for (int i = 0; i < pairsLength; i++) {
64	IBinaryElementValuePair binaryElementValuePair = binaryElementValuePairs[i];
65	MemberValuePair memberValuePair = new MemberValuePair(new String(binaryElementValuePair.getName()));
66	memberValuePair.value = getMemberValue(memberValuePair, binaryElementValuePair.getValue());
67	members[i] = memberValuePair;
68	}
69	}
70	char[] typeName = org.eclipse.jdt.core.Signature.toCharArray(CharOperation.replaceOnCopy(binaryAnnotation.getTypeName(), '/', '.'));
71	return new Annotation(this, new String(typeName)) {
72	public IMemberValuePair[] getMemberValuePairs() throws JavaModelException {
73	return members;
74	}
75	};
76	}	59	}
77	protected Object getMemberValue(MemberValuePair memberValuePair, Object binaryValue) {	60	private IAnnotation[] getStandardAnnotations(long tagBits) {
78	if (binaryValue instanceof Constant) {	61	if ((tagBits & TagBits.AllStandardAnnotationsMask) == 0)
79	return Util.getAnnotationMemberValue(memberValuePair, (Constant) binaryValue);	62	return Annotation.NO_ANNOTATIONS;
80	} else if (binaryValue instanceof IBinaryAnnotation) {	63	ArrayList annotations = new ArrayList();
81	memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;	64
82	return getAnnotation((IBinaryAnnotation) binaryValue);	65	if ((tagBits & TagBits.AnnotationTargetMASK) != 0) {
83	} else if (binaryValue instanceof ClassSignature) {	66	annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_TARGET));
84	memberValuePair.valueKind = IMemberValuePair.K_CLASS;	67	}
85	char[] className = Signature.toCharArray(CharOperation.replaceOnCopy(((ClassSignature) binaryValue).getTypeName(), '/', '.'));	68	if ((tagBits & TagBits.AnnotationRetentionMASK) != 0) {
86	return new String(className);	69	annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_RETENTION));
87	} else if (binaryValue instanceof EnumConstantSignature) {
88	memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
89	EnumConstantSignature enumConstant = (EnumConstantSignature) binaryValue;
90	char[] enumName = Signature.toCharArray(CharOperation.replaceOnCopy(enumConstant.getTypeName(), '/', '.'));
91	char[] qualifiedName = CharOperation.concat(enumName, enumConstant.getEnumConstantName(), '.');
92	return new String(qualifiedName);
93	} else if (binaryValue instanceof Object[]) {
94	memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
95	Object[] binaryValues = (Object[]) binaryValue;
96	int length = binaryValues.length;
97	Object[] values = new Object[length];
98	for (int i = 0; i < length; i++) {
99	int previousValueKind = memberValuePair.valueKind;
100	Object value = getMemberValue(memberValuePair, binaryValues[i]);
101	if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
102	// values are heterogeneous, value kind is thus unknown
103	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
104	}
105	values[i] = value;
106	}
107	if (memberValuePair.valueKind == -1)
108	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
109	return values;
110	} else {
111	memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
112	return null;
113	}	70	}
		71	if ((tagBits & TagBits.AnnotationDeprecated) != 0) {
		72	annotations.add(getAnnotation(TypeConstants.JAVA_LANG_DEPRECATED));
		73	}
		74	if ((tagBits & TagBits.AnnotationDocumented) != 0) {
		75	annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED));
		76	}
		77	if ((tagBits & TagBits.AnnotationInherited) != 0) {
		78	annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_INHERITED));
		79	}
		80	// note that JAVA_LANG_SUPPRESSWARNINGS and JAVA_LANG_OVERRIDE cannot appear in binaries
		81	return (IAnnotation[]) annotations.toArray(new IAnnotation[annotations.size()]);
114	}	82	}
		83
115	public String[] getCategories() throws JavaModelException {	84	public String[] getCategories() throws JavaModelException {
116	SourceMapper mapper= getSourceMapper();	85	SourceMapper mapper= getSourceMapper();
117	if (mapper != null) {	86	if (mapper != null) {

Lines 271-277 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java (-4 / +4 lines)
271	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");	271	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
272	String source = classFile.getSource();	272	String source = classFile.getSource();
273	IJavaElement element = classFile.getElementAt(source.indexOf("class A"));	273	IJavaElement element = classFile.getElementAt(source.indexOf("class A"));
274	assertElementEquals(	274	assertElementExists(
275	"Unexpected element",	275	"Unexpected element",
276	"A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]",	276	"A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]",
277	element);	277	element);
Lines 283-289 Link Here
283	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");	283	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
284	String source = classFile.getSource();	284	String source = classFile.getSource();
285	IJavaElement element = classFile.getElementAt(source.indexOf("public A"));	285	IJavaElement element = classFile.getElementAt(source.indexOf("public A"));
286	assertElementEquals(	286	assertElementExists(
287	"Unexpected element",	287	"Unexpected element",
288	"A() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",	288	"A() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",
289	element);	289	element);
Lines 295-301 Link Here
295	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");	295	IClassFile classFile = this.pkgFragmentRoot.getPackageFragment("x.y").getClassFile("A.class");
296	String source = classFile.getSource();	296	String source = classFile.getSource();
297	IJavaElement element = classFile.getElementAt(source.indexOf("void foo"));	297	IJavaElement element = classFile.getElementAt(source.indexOf("void foo"));
298	assertElementEquals(	298	assertElementExists(
299	"Unexpected element",	299	"Unexpected element",
300	"foo() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",	300	"foo() [in A [in A.class [in x.y [in attach.jar [in AttachSourceTests]]]]]",
301	element);	301	element);
Lines 308-314 Link Here
308	IClassFile classFile = this.innerClasses.getClassFile("X$V.class");	308	IClassFile classFile = this.innerClasses.getClassFile("X$V.class");
309	String source = classFile.getSource();	309	String source = classFile.getSource();
310	IJavaElement element = classFile.getElementAt(source.indexOf("V(String s)"));	310	IJavaElement element = classFile.getElementAt(source.indexOf("V(String s)"));
311	assertElementEquals(	311	assertElementExists(
312	"Unexpected element",	312	"Unexpected element",
313	"V(inner.X, java.lang.String) [in V [in X$V.class [in inner [in innerClasses.jar [in AttachSourceTests]]]]]",	313	"V(inner.X, java.lang.String) [in V [in X$V.class [in inner [in innerClasses.jar [in AttachSourceTests]]]]]",
314	element);	314	element);

Lines 21-27 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ClassFileTests.java (-17 / +35 lines)
21	import org.eclipse.jdt.core.search.IJavaSearchConstants;	21	import org.eclipse.jdt.core.search.IJavaSearchConstants;
22	import org.eclipse.jdt.core.search.IJavaSearchScope;	22	import org.eclipse.jdt.core.search.IJavaSearchScope;
23	import org.eclipse.jdt.core.search.SearchEngine;	23	import org.eclipse.jdt.core.search.SearchEngine;
24	import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;
25		24
26	import junit.framework.Test;	25	import junit.framework.Test;
27		26
Lines 140-145 Link Here
140	"enum MyEnum {\n" +	139	"enum MyEnum {\n" +
141	" FIRST, SECOND;\n" +	140	" FIRST, SECOND;\n" +
142	"}",	141	"}",
		142	"annotated/Y.java",
		143	"package annotated;\n" +
		144	"import java.lang.annotation.*;\n" +
		145	"import static java.lang.annotation.ElementType.*;\n" +
		146	"import static java.lang.annotation.RetentionPolicy.*;\n" +
		147	"@Deprecated\n" +
		148	"@Documented\n" +
		149	"@Inherited\n" +
		150	"@Retention(SOURCE)\n" +
		151	"@Target({PACKAGE, TYPE, ANNOTATION_TYPE, METHOD, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PARAMETER})\n" +
		152	"public @interface Y {\n" +
		153	"}",
143	"varargs/X.java",	154	"varargs/X.java",
144	"package varargs;\n" +	155	"package varargs;\n" +
145	"public class X {\n" +	156	"public class X {\n" +
Lines 161-182 Link Here
161	" }\n" +	172	" }\n" +
162	"}",	173	"}",
163	};	174	};
164	if ((AbstractCompilerTest.getPossibleComplianceLevels() & AbstractCompilerTest.F_1_5) == 0) {
165	int length = pathAndContents.length;
166	System.arraycopy(pathAndContents, 0, pathAndContents = new String[length+4], 0, length);
167	pathAndContents[length] = "java/lang/annotation/Annotation.java";
168	pathAndContents[length+1] =
169	"package java.lang.annotation;\n" +
170	"public interface Annotation {\n" +
171	"}";
172	pathAndContents[length+2] = "java/lang/Enum.java";
173	pathAndContents[length+3] =
174	"package java.lang;\n" +
175	"public abstract class Enum<E extends Enum<E>> {\n" +
176	" protected Enum(String arg1, int arg2) {\n" +
177	" }\n" +
178	"}";
179	}
180	addLibrary(javaProject, "lib.jar", "libsrc.zip", pathAndContents, JavaCore.VERSION_1_5);	175	addLibrary(javaProject, "lib.jar", "libsrc.zip", pathAndContents, JavaCore.VERSION_1_5);
181	this.jarRoot = javaProject.getPackageFragmentRoot(getFile("/P/lib.jar"));	176	this.jarRoot = javaProject.getPackageFragmentRoot(getFile("/P/lib.jar"));
182	}	177	}
Lines 379-384 Link Here
379	}	374	}
380		375
381	/*	376	/*
		377	* Ensures that the standard annotations of a binary type are correct
		378	* (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=248309 )
		379	*/
		380	public void testAnnotations17() throws JavaModelException {
		381	IType type = this.jarRoot.getPackageFragment("annotated").getClassFile("Y.class").getType();
		382	assertAnnotationsEqual(
		383	"@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.PACKAGE})\n" +
		384	"@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.SOURCE)\n" +
		385	"@java.lang.Deprecated\n" +
		386	"@java.lang.annotation.Documented\n" +
		387	"@java.lang.annotation.Inherited\n",
		388	type.getAnnotations());
		389	}
		390
		391	/*
		392	* Ensures that the annotation of a binary type exists
		393	*/
		394	public void testAnnotations18() throws JavaModelException {
		395	IAnnotation annotation = this.jarRoot.getPackageFragment("annotated").getClassFile("X.class").getType().getAnnotation("annotated.MyOtherAnnot");
		396	assertTrue("Annotation should exist", annotation.exists());
		397	}
		398
		399	/*
382	* Ensures that no exception is thrown for a .class file name with a dot	400	* Ensures that no exception is thrown for a .class file name with a dot
383	* (regression test for bug 114140 assertion failed when opening a class file not not the classpath)	401	* (regression test for bug 114140 assertion failed when opening a class file not not the classpath)
384	*/	402	*/