Attachment #34415 for bug #123470




import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.IDependent;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;

		this.resolver = resolver;
	}

	public IAnnotationBinding[] getAnnotations() { 
		IAnnotationBinding[] domInstances = AnnotationBinding.NoAnnotations;
		if (this.binding.isAnnotationType() || this.binding.isClass() || this.binding.isEnum() || this.binding.isInterface()) {
			org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding refType = 
				(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding) this.binding;
			org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations = refType.getAnnotations();
			int length = internalAnnotations == null ? 0 : internalAnnotations.length;
			if (length > 0) {
				domInstances = new AnnotationBinding[length];
				for (int i = 0; i < length; i++)
					domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);
			}




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.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodVerifier;

		return name;
	}

	public IAnnotationBinding[] getAnnotations() { 
		org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] annotations = this.binding.getAnnotations();
		int length;
		if (annotations == null || (length = annotations.length) == 0)
			return AnnotationBinding.NoAnnotations;
		IAnnotationBinding[] domInstances = new AnnotationBinding[length];
		for (int i = 0; i < length; i++)
			domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
		return domInstances; 

		return declaringClass;
	}

	public IAnnotationBinding[] getParameterAnnotations(int index) {
		org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] annotations = this.binding.getParameterAnnotations(index);
		int length;
		if (annotations == null || (length = annotations.length) == 0)
			return AnnotationBinding.NoAnnotations;
		IAnnotationBinding[] domInstances =new AnnotationBinding[length];
		for (int i = 0; i < length; i++)
			domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
		return domInstances; 


	public Object getDefaultValue() {
		if (isAnnotationMember())
			return MemberValuePairBinding.buildDOMValue(this.binding.getDefaultValue(), this.resolver);
		return null;
	}


Lines 175-181 Link Here

(-)dom/org/eclipse/jdt/core/dom/Annotation.java (-1 / +1 lines)
175	* @return the resolved annotation, or <code>null</code> if the annotation cannot be resolved	175	* @return the resolved annotation, or <code>null</code> if the annotation cannot be resolved
176	* @since 3.2	176	* @since 3.2
177	*/	177	*/
178	public IResolvedAnnotation resolveAnnotation() {	178	public IAnnotationBinding resolveAnnotation() {
179	return this.ast.getBindingResolver().resolveAnnotation(this);	179	return this.ast.getBindingResolver().resolveAnnotation(this);
180	}	180	}
181	}	181	}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.dom.BindingResolver;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.IResolvedMemberValuePair;

/**
 * Member value pair which compose of default values.
 */
class ResolvedDefaultValuePair implements IResolvedMemberValuePair {

	private org.eclipse.jdt.internal.compiler.lookup.MethodBinding method;
	private Object domValue;
	private BindingResolver bindingResolver;

static void appendValue(Object value, StringBuffer buffer) {
	if (value instanceof Object[]) {
		Object[] values = (Object[]) value;
		buffer.append('{');
		for (int i = 0, l = values.length; i < l; i++) {
			if (i != 0)
				buffer.append(", "); //$NON-NLS-1$
			appendValue(values[i], buffer);
		}
		buffer.append('}');
	} else if (value instanceof ITypeBinding) {
		buffer.append(((ITypeBinding) value).getName());
		buffer.append(".class"); //$NON-NLS-1$
	} else {
		buffer.append(value);
	}
}

ResolvedDefaultValuePair(org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding, BindingResolver resolver) {
	this.method = binding;
	this.domValue = ResolvedMemberValuePair.buildDOMValue(binding.getDefaultValue(), resolver);
	this.bindingResolver = resolver;
}

public String getName() {
	return new String(this.method.selector);
}

public IMethodBinding getMethodBinding() {
	return this.bindingResolver.getMethodBinding(this.method);
}

public Object getValue() {
	return this.domValue;
}

public boolean isDefault() {
	return true;
}

public String toString() {
	StringBuffer buffer = new StringBuffer();
	toString(buffer);
	return buffer.toString();
}

public void toString(StringBuffer buffer) {
	buffer.append(getName());
	buffer.append(" = "); //$NON-NLS-1$		
	appendValue(getValue(), buffer);
}
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

/**
 * Represents a resolved instance of an annotation's member value pair.
 * Resolved annotation are computed along with other bindings; these objects
 * correspond to {@link MemberValuePair} nodes.
 * 
 * @since 3.2
 */
public interface IResolvedMemberValuePair {
/**
 * Returns the name of the annotation type member.
 * 
 * @return the name of the member
 */
public String getName();

/**
 * Returns the method binding corresponding to the named annotation type member.
 * 
 * @return the method binding for the annotation type member
 */
public IMethodBinding getMethodBinding();

/**
 * Returns the resolved value. Resolved values are represented as follows:
 * <ul>
 * <li>Primitive type - the equivalent boxed object</li>
 * <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
 * <li>java.lang.String - the string value itself</li>
 * <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
 * <li>annotation type - an <code>IResolvedAnnotation</code></li>
 * <li>array type - an <code>Object[]</code> whose elements are as per above
 * (the language only allows single dimensional arrays in annotations)</li>
 * </ul>
 * 	
 * @return the resolved value, or <code>null</code> if none exists
 */
public Object getValue();

/**
 * @return <code>true</code> iff this member value pair's value is the default value.
 *         Returns <code>false</code> otherwise.
 */
public boolean isDefault();
}




import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;

		return (ASTNode) this.bindingsToAstNodes.get(binding);
	}

	synchronized ASTNode findDeclaringNode(IAnnotationBinding instance) {
		if (instance == null)
			return null;
		return (ASTNode) this.bindingsToAstNodes.get(instance);

		return null;
	}
	
	synchronized IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalInstance) {
		if (internalInstance == null) return null;
		IAnnotationBinding domInstance = 
			(IAnnotationBinding) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);
		if (domInstance != null)
			return domInstance;
		domInstance = new AnnotationBinding(internalInstance, this);
		this.bindingTables.compilerBindingsToASTBindings.put(internalInstance, domInstance);
		return domInstance;
	}

		return null;
	}

	synchronized IAnnotationBinding resolveAnnotation(final Annotation domASTNode) {
		Object oldNode = this.newAstToOldAst.get(domASTNode);
		if (oldNode instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
			org.eclipse.jdt.internal.compiler.ast.Annotation internalAstNode = 
				(org.eclipse.jdt.internal.compiler.ast.Annotation) oldNode;
			
			IAnnotationBinding domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());
			if (domAnnotation == null)
				return null;
			this.bindingsToAstNodes.put(domAnnotation, domASTNode);			




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

/**
 * Internal class.
 */
class ResolvedMemberValuePair implements IResolvedMemberValuePair {
	static final ResolvedMemberValuePair[] NoPair = new ResolvedMemberValuePair[0];
	private static final Object NoValue = new Object();
	private static final Object[] EmptyArray = new Object[0];

	private ElementValuePair internalPair;
	private Object value = null;
	private BindingResolver bindingResolver;

static Object buildDOMValue(final Object internalObject, BindingResolver resolver) {
	if (internalObject == null)
		return null;

	if (internalObject instanceof Constant) {
		Constant constant = (Constant) internalObject;
		switch (constant.typeID()) {
			case TypeIds.T_boolean:
				return Boolean.valueOf(constant.booleanValue());
			case TypeIds.T_byte:
				return new Byte(constant.byteValue());
			case TypeIds.T_char:
				return new Character(constant.charValue());
			case TypeIds.T_double:
				return new Double(constant.doubleValue());
			case TypeIds.T_float:
				return new Float(constant.floatValue());
			case TypeIds.T_int:
				return new Integer(constant.intValue());
			case TypeIds.T_long:
				return new Long(constant.longValue());
			case TypeIds.T_short:
				return new Short(constant.shortValue());
			case TypeIds.T_JavaLangString:
				return constant.stringValue();
		}
	} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {
		return resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) internalObject);
	} else if (internalObject instanceof AnnotationBinding) {
		return resolver.getAnnotationInstance((AnnotationBinding) internalObject);
	} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.FieldBinding) {
		return resolver.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.FieldBinding) internalObject);
	} else if (internalObject instanceof Object[]) {
		Object[] elements = (Object[]) internalObject;
		int length = elements.length;
		Object[] values = length == 0 ? EmptyArray : new Object[length];
		for (int i = 0; i < length; i++)
			values[i] = buildDOMValue(elements[i], resolver);
		return values;
	}
	throw new IllegalStateException(internalObject.toString()); // should never get here
}

ResolvedMemberValuePair(ElementValuePair pair, BindingResolver resolver) {
	this.internalPair = pair;
	this.bindingResolver = resolver;
}

public IMethodBinding getMethodBinding() {
	return this.bindingResolver.getMethodBinding(this.internalPair.getMethodBinding());
}

public String getName() {
	if (this.internalPair == null)
		return null;
	final char[] membername = this.internalPair.getName();
	return membername == null ? null : new String(membername);
}

public Object getValue() {
	if (value == null)
		init();
	return value == NoValue ? null : this.value;
}

private void init() {
	this.value = buildDOMValue(this.internalPair.getValue(), this.bindingResolver);
	if (this.value == null)
		this.value = NoValue;
}

char[] internalName() {
	return this.internalPair == null ? null : this.internalPair.getName();
}

public boolean isDefault() {
	return false;
}

public String toString() {
	StringBuffer buffer = new StringBuffer();
	toString(buffer);
	return buffer.toString();
}

public void toString(StringBuffer buffer) {
	buffer.append(getName());
	buffer.append(" = "); //$NON-NLS-1$		
	ResolvedDefaultValuePair.appendValue(getValue(), buffer);
}
}




	 * This method always returns <code>null</code> when the resolved annotation
	 * comes from a different AST.
	 * 
	 * @param annotationBinding the resolved annotation
	 * @return the corresponding node where the given resolved annotation is declared,
	 * or <code>null</code> if the resolved annotation does not correspond to a node in this
	 * compilation unit or if bindings were not requested when this AST was built
	 * @since 3.2
	 */
	public ASTNode findDeclaringNode(IAnnotationBinding annotationBinding) {
		return this.ast.getBindingResolver().findDeclaringNode(annotationBinding);
	}

	/**




import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.core.NameLookup;
import org.eclipse.jdt.internal.core.SearchableEnvironment;

		this.resolver = resolver;
	}

	public IAnnotationBinding[] getAnnotations() {
		try {
			INameEnvironment nameEnvironment = this.binding.environment.nameEnvironment; 
			if (!(nameEnvironment instanceof SearchableEnvironment))
				return AnnotationBinding.NoAnnotations;
			NameLookup nameLookup = ((SearchableEnvironment) nameEnvironment).nameLookup;
			if (nameLookup == null)
				return AnnotationBinding.NoAnnotations;
			final String pkgName = getName();
			IPackageFragment[] pkgs = nameLookup.findPackageFragments(pkgName, false/*exact match*/);
			if (pkgs == null)
				return AnnotationBinding.NoAnnotations;

			for (int i = 0, len = pkgs.length; i < len; i++) {
				int fragType = pkgs[i].getKind();

							if (pkgDecl != null) {
								List annos = pkgDecl.annotations();
								if (annos == null || annos.isEmpty())
									return AnnotationBinding.NoAnnotations; 
								IAnnotationBinding[] result = new IAnnotationBinding[annos.size()];
								int index=0;
		 						for (Iterator it = annos.iterator(); it.hasNext(); index++) {
									result[index] = ((Annotation) it.next()).resolveAnnotation();
									// not resolving bindings
									if (result[index] == null)
										return AnnotationBinding.NoAnnotations;							
								}
								return result;
							}

						if (answer != null && answer.isBinaryType()) {
							IBinaryType type = answer.getBinaryType();
							IBinaryAnnotation[] binaryAnnotations = type.getAnnotations();
							org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] binaryInstances =
								BinaryTypeBinding.createAnnotations(binaryAnnotations, this.binding.environment);
							org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] allInstances =
								org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding.addStandardAnnotations(binaryInstances, type.getTagBits(), this.binding.environment);
							int total = allInstances.length;
							IAnnotationBinding[] domInstances = new AnnotationBinding[total];
							for (int a = 0; a < total; a++) {
								domInstances[a] = this.resolver.getAnnotationInstance(allInstances[a]);
								if (domInstances[a] == null) // not resolving binding
									return AnnotationBinding.NoAnnotations; 
							}
							return domInstances;
						}
				}	
			}		
		} catch(JavaModelException e) {
			return AnnotationBinding.NoAnnotations;
		}		
		return AnnotationBinding.NoAnnotations;
	}

	/*




	 * is not the binding for an annotation type member.
	 * <p>
	 * Resolved values are represented as follows (same as for
	 * {@link IMemberValuePairBinding#getValue()}):
	 * <ul>
	 * <li>Primitive type - the equivalent boxed object</li>
	 * <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
	 * <li>java.lang.String - the string value itself</li>
	 * <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
	 * <li>annotation type - an <code>IAnnotationBinding</code></li>
	 * <li>array type - an <code>Object[]</code> whose elements are as per above
	 * (the language only allows single dimensional arrays in annotations)</li>
	 * </ul>

	 * not a valid index
	 * @since 3.2
	 */
	public IAnnotationBinding[] getParameterAnnotations(int paramIndex);

	/**
	 * Returns a list of type bindings representing the formal parameter types,





package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;

	 * @return the corresponding node where the bindings is declared, 
	 *    or <code>null</code> if none
	 */
	ASTNode findDeclaringNode(IAnnotationBinding instance) {
		return null;
	}


	 * @param instance the old annotation 
	 * @return the new DOM annotation
	 */
	IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding instance) {
		return null;
	}


	 * @return the DOM annotation representation for the given ast node, or 
	 *    <code>null</code> if none is available
	 */
	IAnnotationBinding resolveAnnotation(Annotation annotation) {
		return null;
	}





/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.util.*;

/**
 * Internal class
 */
class ResolvedAnnotation implements IResolvedAnnotation {
	static final ResolvedAnnotation[] NoAnnotations = new ResolvedAnnotation[0];
	private AnnotationBinding internalAnnotation;
	private BindingResolver bindingResolver;

	ResolvedAnnotation(AnnotationBinding annotation, BindingResolver resolver) {
		if (annotation == null)
			throw new IllegalStateException();
		internalAnnotation = annotation;
		bindingResolver = resolver;
	}

	public ITypeBinding getAnnotationType() {
		ITypeBinding binding = this.bindingResolver.getTypeBinding(this.internalAnnotation.getAnnotationType());
		if (binding == null || !binding.isAnnotation())
			return null;
		return binding;
	}

	public IResolvedMemberValuePair[] getDeclaredMemberValuePairs() {
		ElementValuePair[] internalPairs = this.internalAnnotation.getElementValuePairs();
		int length = internalPairs.length;
		IResolvedMemberValuePair[] pairs = length == 0 ? ResolvedMemberValuePair.NoPair : new ResolvedMemberValuePair[length];
		for (int i = 0; i < length; i++)
			pairs[i] = new ResolvedMemberValuePair(internalPairs[i], this.bindingResolver);
		return pairs;
	}

	public IResolvedMemberValuePair[] getAllMemberValuePairs() {
		IResolvedMemberValuePair[] pairs = getDeclaredMemberValuePairs();
		ReferenceBinding typeBinding = this.internalAnnotation.getAnnotationType();
		if (typeBinding == null) return pairs;
		MethodBinding[] methods = typeBinding.methods();
		int methodLength = methods == null ? 0 : methods.length;
		if (methodLength == 0) return pairs;

		int declaredLength = pairs.length;
		if (declaredLength == methodLength)
			return pairs;

		HashtableOfObject table = new HashtableOfObject(declaredLength);
		for (int i = 0; i < declaredLength; i++)
			table.put(((ResolvedMemberValuePair) pairs[i]).internalName(), pairs[i]);

		// handle case of more methods than declared members
		IResolvedMemberValuePair[] allPairs = new  IResolvedMemberValuePair[methodLength];
		for (int i = 0; i < methodLength; i++) {
			Object pair = table.get(methods[i].selector);
			allPairs[i] = pair == null ? new ResolvedDefaultValuePair(methods[i], this.bindingResolver) : (IResolvedMemberValuePair) pair;
		}
		return allPairs;
	}

	public String toString() {
		ITypeBinding type = getAnnotationType();
		final StringBuffer buffer = new StringBuffer();
		buffer.append('@');
		if (type != null)
			buffer.append(type.getName());
		buffer.append('(');
		IResolvedMemberValuePair[] pairs = getDeclaredMemberValuePairs();
		for (int i = 0, len = pairs.length; i < len; i++) {
			if (i != 0)
				buffer.append(", "); //$NON-NLS-1$
			buffer.append(pairs[i].toString());
		}
		buffer.append(')');
		return buffer.toString();
	}
}




	public static final int METHOD = 4;

	/**
	 * Kind constant (value 5) indicating an annotation binding.
	 * Bindings of this kind can be safely cast to <code>IAnnotationBinding</code>.
	 * 
	 * @see #getKind()
	 * @see IAnnotationBinding
	 * @since 3.2
	 */
	public static final int ANNOTATION = 5;

	/**
	 * Kind constant (value 6) indicating a member value pair binding.
	 * Bindings of this kind can be safely cast to <code>IMemberValuePairBinding</code>.
	 * 
	 * @see #getKind()
	 * @see IMemberValuePairBinding
	 * @since 3.2
	 */
	public static final int MEMBER_VALUE_PAIR = 6;

	/**
	 * Return the resolved annotations associated with this binding.
	 * <ul>
	 * <li>Package bindings - these are annotations on a package declaration.

	 * parameterized.</li>
	 * <li>Variable bindings - these are annotations on a field, enum constant,
	 * or formal parameter declaration.</li>
	 * <li>Annotation bindings - an empty array is always returned</li>
	 * <li>Member value pair bindings - an empty array is always returned<li>
	 * </ul>
	 * 
	 * @return the list of resolved annotations, or the empty list if there are no
	 * annotations associated with the object
	 * @since 3.2
	 */
	public IAnnotationBinding[] getAnnotations();

	/**
	 * Returns the kind of bindings this is. That is one of the kind constants:
	 * <code>PACKAGE</code>,
	 * @return one of the kind constants:
	 * 	<code>PACKAGE</code>,
	 * 	<code>TYPE</code>,
	 * 	<code>VARIABLE</code>,
	 * 	<code>METHOD</code>,
	 * 	<code>ANNOTATION</code>,
	 * or <code>MEMBER_VALUE_PAIR</code>.
	 * <p>
	 * Note that additional kinds might be added in the
	 * future, so clients should not assume this list is exhaustive and 
	 * should program defensively, e.g. by having a reasonable default
	 * in a switch statement.
	 * </p>
	 * @return one of the kind constants
	 */
	public int getKind();
	

	 * <li>the "length" field of an array type</li>
	 * <li>the default constructor of a source class</li>
	 * <li>the constructor of an anonymous class</li>
	 * <li>member value pairs</li>
	 * </ul>
	 * For all other kind of type, method, variable, annotation and package bindings,
	 * this method returns non-<code>null</code>.
	 * </p>
	 * 

	 * type</li>
	 * </ul>
	 * </p>
	 * <p>Note that the key for annotation bindings and member value pair bindings is
	 * not yet implemented. This returns <code>null</code> for these 2 kinds of bindings.
	 * </p>
	 * 
	 * @return the key for this binding
	 */




import org.eclipse.jdt.core.util.IModifierConstants;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

		this.binding = binding;
	}

	public IAnnotationBinding[] getAnnotations() { 
		org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations = this.binding.getAnnotations();
		// the variable is not an enum constant nor a field nor an argument.
		int length = internalAnnotations == null ? 0 : internalAnnotations.length;
		IAnnotationBinding[] domInstances =
			length == 0 ? AnnotationBinding.NoAnnotations : new AnnotationBinding[length];
		for (int i = 0; i < length; i++)
			domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);
		return domInstances;                                                                  




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

/**
 * Represents an resolved annotation. Resolved annotation are computed along with other
 * bindings; they correspond to {@link Annotation} nodes.
 * 
 * @since 3.2
 */
public interface IResolvedAnnotation {
/**
 * Returns the type of the annotation. The resulting type binding will always
 * return <code>true</code>	to <code>ITypeBinding.isAnnotation()</code>.
 * 
 * @return the type of the annotation
 */
ITypeBinding getAnnotationType();

/**
 * Returns the list of declared member value pairs for this annotation.
 * Returns an empty list for a <code>MarkerAnnotation</code>, a one element
 * list for a <code>SingleMemberAnnotation</code>, and one entry for each
 * of the explicitly listed values in a <code>NormalAnnotation</code>.
 * <p>
 * Note that the list only includes entries for annotation type members that are
 * explicitly mentioned in the annotation. The list does not include any 
 * annotation type members with default values that are merely implied.
 * Use {@link #getAllMemberValuePairs()} to get those as well.
 * </p>
 * 
 * @return a possibly empty list of resolved member value pairs
 */
IResolvedMemberValuePair[] getDeclaredMemberValuePairs();

/**
 * Returns the complete list of member value pairs for this annotation, including
 * ones explicitly listed in the annotation as well as entries for 
 * annotation type members with default values that are implied.
 * 
 * @return a possibly empty list of resolved member value pairs
 */
IResolvedMemberValuePair[] getAllMemberValuePairs();
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *    IBM Corporation - changed interface to extend IBinding
 *    IBM Corporation - renamed from IResolvedAnnotation to IAnnotationBinding
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

/**
 * Represents an resolved annotation. Resolved annotation are computed along with other
 * bindings; they correspond to {@link Annotation} nodes.
 * <p>
 * This interface is not intended to be implemented by clients.
 * </p>
 * 
 * @since 3.2
 */
public interface IAnnotationBinding extends IBinding {

	/**
	 * Returns the complete list of member value pairs for this annotation, including
	 * ones explicitly listed in the annotation as well as entries for 
	 * annotation type members with default values that are implied.
	 * 
	 * @return a possibly empty list of resolved member value pairs
	 */
	IMemberValuePairBinding[] getAllMemberValuePairs();
	
	/**
	 * Returns the type of the annotation. The resulting type binding will always
	 * return <code>true</code>	to <code>ITypeBinding.isAnnotation()</code>.
	 * 
	 * @return the type of the annotation
	 */
	ITypeBinding getAnnotationType();
	
	/**
	 * Returns the list of declared member value pairs for this annotation.
	 * Returns an empty list for a <code>MarkerAnnotation</code>, a one element
	 * list for a <code>SingleMemberAnnotation</code>, and one entry for each
	 * of the explicitly listed values in a <code>NormalAnnotation</code>.
	 * <p>
	 * Note that the list only includes entries for annotation type members that are
	 * explicitly mentioned in the annotation. The list does not include any 
	 * annotation type members with default values that are merely implied.
	 * Use {@link #getAllMemberValuePairs()} to get those as well.
	 * </p>
	 * 
	 * @return a possibly empty list of resolved member value pairs
	 */
	IMemberValuePairBinding[] getDeclaredMemberValuePairs();
	
	/**
	 * Returns the name of the annotation type.
	 * 
	 * @return the name of the annotation type
	 */
	public String getName();
	
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *    IBM Corporation - changed interface to extend IBinding
 *    IBM Corporation - renamed from IResolvedMemberValuePair to IMemberValuePairBinding
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

/**
 * Represents a resolved instance of an annotation's member value pair.
 * Resolved annotation are computed along with other bindings; these objects
 * correspond to {@link MemberValuePair} nodes.
 * <p>
 * This interface is not intended to be implemented by clients.
 * </p>
 * 
 * @since 3.2
 */
public interface IMemberValuePairBinding extends IBinding {
/**
 * Returns the name of the annotation type member.
 * 
 * @return the name of the member
 */
public String getName();

/**
 * Returns the method binding corresponding to the named annotation type member.
 * 
 * @return the method binding for the annotation type member
 */
public IMethodBinding getMethodBinding();

/**
 * Returns the resolved value. Resolved values are represented as follows:
 * <ul>
 * <li>Primitive type - the equivalent boxed object</li>
 * <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
 * <li>java.lang.String - the string value itself</li>
 * <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
 * <li>annotation type - an <code>IAnnotationBinding</code></li>
 * <li>array type - an <code>Object[]</code> whose elements are as per above
 * (the language only allows single dimensional arrays in annotations)</li>
 * </ul>
 * 	
 * @return the resolved value, or <code>null</code> if none exists
 */
public Object getValue();

/**
 * @return <code>true</code> iff this member value pair's value is the default value.
 *         Returns <code>false</code> otherwise.
 */
public boolean isDefault();
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *    IBM Corporation - implemented methods from IBinding
 *    IBM Corporation - renamed from ResolvedDefaultValuePair to DefaultValuePairBinding
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.dom.BindingResolver;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.IMemberValuePairBinding;

/**
 * Member value pair which compose of default values.
 */
class DefaultValuePairBinding implements IMemberValuePairBinding {

	private org.eclipse.jdt.internal.compiler.lookup.MethodBinding method;
	private Object domValue;
	private BindingResolver bindingResolver;

	static void appendValue(Object value, StringBuffer buffer) {
		if (value instanceof Object[]) {
			Object[] values = (Object[]) value;
			buffer.append('{');
			for (int i = 0, l = values.length; i < l; i++) {
				if (i != 0)
					buffer.append(", "); //$NON-NLS-1$
				appendValue(values[i], buffer);
			}
			buffer.append('}');
		} else if (value instanceof ITypeBinding) {
			buffer.append(((ITypeBinding) value).getName());
			buffer.append(".class"); //$NON-NLS-1$
		} else {
			buffer.append(value);
		}
	}
	
	DefaultValuePairBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding, BindingResolver resolver) {
		this.method = binding;
		this.domValue = MemberValuePairBinding.buildDOMValue(binding.getDefaultValue(), resolver);
		this.bindingResolver = resolver;
	}
	
	public IAnnotationBinding[] getAnnotations() {
		return AnnotationBinding.NoAnnotations;
	}

	public IJavaElement getJavaElement() {
		return null;
	}
	
	public String getKey() {
		// TODO when implementing, update spec in IBinding
		return null;
	}

	public int getKind() {
		return IBinding.MEMBER_VALUE_PAIR;
	}

	public IMethodBinding getMethodBinding() {
		return this.bindingResolver.getMethodBinding(this.method);
	}
	
	public int getModifiers() {
		return -1;
	}

	public String getName() {
		return new String(this.method.selector);
	}
	
	public Object getValue() {
		return this.domValue;
	}
	
	public boolean isDefault() {
		return true;
	}
	
	public boolean isDeprecated() {
		return false;
	}
	
	public boolean isEqualTo(IBinding binding) {
		if (this == binding)
			return true;
		if (binding.getKind() != IBinding.MEMBER_VALUE_PAIR)
			return false;
		IMemberValuePairBinding other = (IMemberValuePairBinding) binding;
		if (!getMethodBinding().isEqualTo(other.getMethodBinding()))
			return false;
		Object value = getValue();
		if (value == null)
			return other.getValue() == null;
		return value.equals(other.getValue());
	}

	public boolean isSynthetic() {
		return false;
	}

	public String toString() {
		StringBuffer buffer = new StringBuffer();
		toString(buffer);
		return buffer.toString();
	}
	
	public void toString(StringBuffer buffer) {
		buffer.append(getName());
		buffer.append(" = "); //$NON-NLS-1$		
		appendValue(getValue(), buffer);
	}
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *    IBM Corporation - implemented methods from IBinding
 *    IBM Corporation - renamed from ResolvedAnnotation to AnnotationBinding
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.util.*;

/**
 * Internal class
 */
class AnnotationBinding implements IAnnotationBinding {
	static final AnnotationBinding[] NoAnnotations = new AnnotationBinding[0];
	private org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalAnnotation;
	private BindingResolver bindingResolver;

	AnnotationBinding(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding annotation, BindingResolver resolver) {
		if (annotation == null)
			throw new IllegalStateException();
		internalAnnotation = annotation;
		bindingResolver = resolver;
	}
	
	public IAnnotationBinding[] getAnnotations() {
		return NoAnnotations;
	}

	public ITypeBinding getAnnotationType() {
		ITypeBinding binding = this.bindingResolver.getTypeBinding(this.internalAnnotation.getAnnotationType());
		if (binding == null || !binding.isAnnotation())
			return null;
		return binding;
	}
	
	public IMemberValuePairBinding[] getDeclaredMemberValuePairs() {
		ElementValuePair[] internalPairs = this.internalAnnotation.getElementValuePairs();
		int length = internalPairs.length;
		IMemberValuePairBinding[] pairs = length == 0 ? MemberValuePairBinding.NoPair : new MemberValuePairBinding[length];
		for (int i = 0; i < length; i++)
			pairs[i] = new MemberValuePairBinding(internalPairs[i], this.bindingResolver);
		return pairs;
	}

	public IMemberValuePairBinding[] getAllMemberValuePairs() {
		IMemberValuePairBinding[] pairs = getDeclaredMemberValuePairs();
		ReferenceBinding typeBinding = this.internalAnnotation.getAnnotationType();
		if (typeBinding == null) return pairs;
		MethodBinding[] methods = typeBinding.methods();
		int methodLength = methods == null ? 0 : methods.length;
		if (methodLength == 0) return pairs;

		int declaredLength = pairs.length;
		if (declaredLength == methodLength)
			return pairs;

		HashtableOfObject table = new HashtableOfObject(declaredLength);
		for (int i = 0; i < declaredLength; i++)
			table.put(((MemberValuePairBinding) pairs[i]).internalName(), pairs[i]);

		// handle case of more methods than declared members
		IMemberValuePairBinding[] allPairs = new  IMemberValuePairBinding[methodLength];
		for (int i = 0; i < methodLength; i++) {
			Object pair = table.get(methods[i].selector);
			allPairs[i] = pair == null ? new DefaultValuePairBinding(methods[i], this.bindingResolver) : (IMemberValuePairBinding) pair;
		}
		return allPairs;
	}
	
	public IJavaElement getJavaElement() {
		ITypeBinding annotationType = getAnnotationType();
		if (annotationType == null)
			return null;
		return annotationType.getJavaElement();
	}

	public String getKey() {
		// TODO when implementing, update spec in IBinding
		return null;
	}

	public int getKind() {
		return IBinding.ANNOTATION;
	}

	public int getModifiers() {
		return -1;
	}

	public String getName() {
		ITypeBinding annotationType = getAnnotationType();
		if (annotationType == null)
			return new String(this.internalAnnotation.getAnnotationType().sourceName());
		else
			return annotationType.getName();
	}
	
	public boolean isDeprecated() {
		return false;
	}
	
	public boolean isEqualTo(IBinding binding) {
		if (this == binding)
			return true;
		if (binding.getKind() != IBinding.ANNOTATION)
			return false;
		IAnnotationBinding other = (IAnnotationBinding) binding;
		if (!getAnnotationType().isEqualTo(other.getAnnotationType()))
			return false;
		IMemberValuePairBinding[] memberValuePairs = getDeclaredMemberValuePairs();
		IMemberValuePairBinding[] otherMemberValuePairs = other.getDeclaredMemberValuePairs();
		if (memberValuePairs.length != otherMemberValuePairs.length)
			return false;
		for (int i = 0, length = memberValuePairs.length; i < length; i++) {
			if (!memberValuePairs[i].isEqualTo(otherMemberValuePairs[i]))
				return false;
		}
		return true;
	}
	
	public boolean isSynthetic() {
		return false;
	}

	public String toString() {
		ITypeBinding type = getAnnotationType();
		final StringBuffer buffer = new StringBuffer();
		buffer.append('@');
		if (type != null)
			buffer.append(type.getName());
		buffer.append('(');
		IMemberValuePairBinding[] pairs = getDeclaredMemberValuePairs();
		for (int i = 0, len = pairs.length; i < len; i++) {
			if (i != 0)
				buffer.append(", "); //$NON-NLS-1$
			buffer.append(pairs[i].toString());
		}
		buffer.append(')');
		return buffer.toString();
	}
	
}




/*******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    tyeung@bea.com - initial API and implementation
 *    IBM Corporation - implemented methods from IBinding
 *    IBM Corporation - renamed from ResolvedMemberValuePair to MemberValuePairBinding
 *******************************************************************************/
package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

/**
 * Internal class.
 */
class MemberValuePairBinding implements IMemberValuePairBinding {
	static final MemberValuePairBinding[] NoPair = new MemberValuePairBinding[0];
	private static final Object NoValue = new Object();
	private static final Object[] EmptyArray = new Object[0];

	private ElementValuePair internalPair;
	private Object value = null;
	private BindingResolver bindingResolver;

	static Object buildDOMValue(final Object internalObject, BindingResolver resolver) {
		if (internalObject == null)
			return null;
	
		if (internalObject instanceof Constant) {
			Constant constant = (Constant) internalObject;
			switch (constant.typeID()) {
				case TypeIds.T_boolean:
					return Boolean.valueOf(constant.booleanValue());
				case TypeIds.T_byte:
					return new Byte(constant.byteValue());
				case TypeIds.T_char:
					return new Character(constant.charValue());
				case TypeIds.T_double:
					return new Double(constant.doubleValue());
				case TypeIds.T_float:
					return new Float(constant.floatValue());
				case TypeIds.T_int:
					return new Integer(constant.intValue());
				case TypeIds.T_long:
					return new Long(constant.longValue());
				case TypeIds.T_short:
					return new Short(constant.shortValue());
				case TypeIds.T_JavaLangString:
					return constant.stringValue();
			}
		} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {
			return resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) internalObject);
		} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding) {
			return resolver.getAnnotationInstance((org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding) internalObject);
		} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.FieldBinding) {
			return resolver.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.FieldBinding) internalObject);
		} else if (internalObject instanceof Object[]) {
			Object[] elements = (Object[]) internalObject;
			int length = elements.length;
			Object[] values = length == 0 ? EmptyArray : new Object[length];
			for (int i = 0; i < length; i++)
				values[i] = buildDOMValue(elements[i], resolver);
			return values;
		}
		throw new IllegalStateException(internalObject.toString()); // should never get here
	}
	
	MemberValuePairBinding(ElementValuePair pair, BindingResolver resolver) {
		this.internalPair = pair;
		this.bindingResolver = resolver;
	}
	
	public IAnnotationBinding[] getAnnotations() {
		return AnnotationBinding.NoAnnotations;
	}

	public IJavaElement getJavaElement() {
		return null;
	}
		
	public String getKey() {
		// TODO when implementing, update spec in IBinding
		return null;
	}

	public int getKind() {
		return IBinding.MEMBER_VALUE_PAIR;
	}

	public IMethodBinding getMethodBinding() {
		return this.bindingResolver.getMethodBinding(this.internalPair.getMethodBinding());
	}
	
	public int getModifiers() {
		return -1;
	}

	public String getName() {
		if (this.internalPair == null)
			return null;
		final char[] membername = this.internalPair.getName();
		return membername == null ? null : new String(membername);
	}
	
	public Object getValue() {
		if (value == null)
			init();
		return value == NoValue ? null : this.value;
	}
	
	private void init() {
		this.value = buildDOMValue(this.internalPair.getValue(), this.bindingResolver);
		if (this.value == null)
			this.value = NoValue;
	}
	
	char[] internalName() {
		return this.internalPair == null ? null : this.internalPair.getName();
	}
	
	public boolean isDefault() {
		return false;
	}
	
	public boolean isDeprecated() {
		return false;
	}

	public boolean isEqualTo(IBinding binding) {
		if (this == binding)
			return true;
		if (binding.getKind() != IBinding.MEMBER_VALUE_PAIR)
			return false;
		IMemberValuePairBinding other = (IMemberValuePairBinding) binding;
		if (!getMethodBinding().isEqualTo(other.getMethodBinding()))
			return false;
		if (this.value == null)
			return other.getValue() == null;
		return this.value.equals(other.getValue());
	}

	public boolean isSynthetic() {
		return false;
	}

	public String toString() {
		StringBuffer buffer = new StringBuffer();
		toString(buffer);
		return buffer.toString();
	}
	
	public void toString(StringBuffer buffer) {
		buffer.append(getName());
		buffer.append(" = "); //$NON-NLS-1$		
		DefaultValuePairBinding.appendValue(getValue(), buffer);
	}
}

Lines 368-374 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java (-1 / +1 lines)
368	ITypeBinding typeBinding = typeDecl.resolveBinding();	368	ITypeBinding typeBinding = typeDecl.resolveBinding();
369	if (typeBinding == null) continue;	369	if (typeBinding == null) continue;
370	typeBinding = typeBinding.getAnnotations()[0].getAnnotationType();	370	typeBinding = typeBinding.getAnnotations()[0].getAnnotationType();
371	IResolvedAnnotation targetValue = typeBinding.getAnnotations()[0];	371	IAnnotationBinding targetValue = typeBinding.getAnnotations()[0];
372	IMethodBinding method = targetValue.getDeclaredMemberValuePairs()[0].getMethodBinding();	372	IMethodBinding method = targetValue.getDeclaredMemberValuePairs()[0].getMethodBinding();
373	if (!"value".equals(method.getName()))	373	if (!"value".equals(method.getName()))
374	problems.add(new ParticipantProblem("method " + method.getName() + " not found", file.getName()));	374	problems.add(new ParticipantProblem("method " + method.getName() + " not found", file.getName()));

Return to bug 123470

Lines 20-26 Link Here

(-)dom/org/eclipse/jdt/core/dom/MethodBinding.java (-10 / +9 lines)
20	import org.eclipse.jdt.core.JavaModelException;	20	import org.eclipse.jdt.core.JavaModelException;
21	import org.eclipse.jdt.core.Signature;	21	import org.eclipse.jdt.core.Signature;
22	import org.eclipse.jdt.core.compiler.CharOperation;	22	import org.eclipse.jdt.core.compiler.CharOperation;
23	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
24	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;	23	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
25	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;	24	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
26	import org.eclipse.jdt.internal.compiler.lookup.MethodVerifier;	25	import org.eclipse.jdt.internal.compiler.lookup.MethodVerifier;
Lines 102-113 Link Here
102	return name;	101	return name;
103	}	102	}
104		103
105	public IResolvedAnnotation[] getAnnotations() {	104	public IAnnotationBinding[] getAnnotations() {
106	AnnotationBinding[] annotations = this.binding.getAnnotations();	105	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] annotations = this.binding.getAnnotations();
107	int length;	106	int length;
108	if (annotations == null \|\| (length = annotations.length) == 0)	107	if (annotations == null \|\| (length = annotations.length) == 0)
109	return ResolvedAnnotation.NoAnnotations;	108	return AnnotationBinding.NoAnnotations;
110	IResolvedAnnotation[] domInstances = new ResolvedAnnotation[length];	109	IAnnotationBinding[] domInstances = new AnnotationBinding[length];
111	for (int i = 0; i < length; i++)	110	for (int i = 0; i < length; i++)
112	domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);	111	domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
113	return domInstances;	112	return domInstances;
Lines 123-134 Link Here
123	return declaringClass;	122	return declaringClass;
124	}	123	}
125		124
126	public IResolvedAnnotation[] getParameterAnnotations(int index) {	125	public IAnnotationBinding[] getParameterAnnotations(int index) {
127	AnnotationBinding[] annotations = this.binding.getParameterAnnotations(index);	126	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] annotations = this.binding.getParameterAnnotations(index);
128	int length;	127	int length;
129	if (annotations == null \|\| (length = annotations.length) == 0)	128	if (annotations == null \|\| (length = annotations.length) == 0)
130	return ResolvedAnnotation.NoAnnotations;	129	return AnnotationBinding.NoAnnotations;
131	IResolvedAnnotation[] domInstances =new ResolvedAnnotation[length];	130	IAnnotationBinding[] domInstances =new AnnotationBinding[length];
132	for (int i = 0; i < length; i++)	131	for (int i = 0; i < length; i++)
133	domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);	132	domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
134	return domInstances;	133	return domInstances;
Lines 166-172 Link Here
166		165
167	public Object getDefaultValue() {	166	public Object getDefaultValue() {
168	if (isAnnotationMember())	167	if (isAnnotationMember())
169	return ResolvedMemberValuePair.buildDOMValue(this.binding.getDefaultValue(), this.resolver);	168	return MemberValuePairBinding.buildDOMValue(this.binding.getDefaultValue(), this.resolver);
170	return null;	169	return null;
171	}	170	}
172		171

Lines 43-49 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java (-8 / +7 lines)
43	import org.eclipse.jdt.internal.compiler.ast.ThisReference;	43	import org.eclipse.jdt.internal.compiler.ast.ThisReference;
44	import org.eclipse.jdt.internal.compiler.ast.TypeReference;	44	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
45	import org.eclipse.jdt.internal.compiler.impl.Constant;	45	import org.eclipse.jdt.internal.compiler.impl.Constant;
46	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
47	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;	46	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
48	import org.eclipse.jdt.internal.compiler.lookup.Binding;	47	import org.eclipse.jdt.internal.compiler.lookup.Binding;
49	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	48	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
Lines 178-184 Link Here
178	return (ASTNode) this.bindingsToAstNodes.get(binding);	177	return (ASTNode) this.bindingsToAstNodes.get(binding);
179	}	178	}
180		179
181	synchronized ASTNode findDeclaringNode(IResolvedAnnotation instance) {	180	synchronized ASTNode findDeclaringNode(IAnnotationBinding instance) {
182	if (instance == null)	181	if (instance == null)
183	return null;	182	return null;
184	return (ASTNode) this.bindingsToAstNodes.get(instance);	183	return (ASTNode) this.bindingsToAstNodes.get(instance);
Lines 355-367 Link Here
355	return null;	354	return null;
356	}	355	}
357		356
358	synchronized IResolvedAnnotation getAnnotationInstance(AnnotationBinding internalInstance) {	357	synchronized IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalInstance) {
359	if (internalInstance == null) return null;	358	if (internalInstance == null) return null;
360	IResolvedAnnotation domInstance =	359	IAnnotationBinding domInstance =
361	(IResolvedAnnotation) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);	360	(IAnnotationBinding) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);
362	if (domInstance != null)	361	if (domInstance != null)
363	return domInstance;	362	return domInstance;
364	domInstance = new ResolvedAnnotation(internalInstance, this);	363	domInstance = new AnnotationBinding(internalInstance, this);
365	this.bindingTables.compilerBindingsToASTBindings.put(internalInstance, domInstance);	364	this.bindingTables.compilerBindingsToASTBindings.put(internalInstance, domInstance);
366	return domInstance;	365	return domInstance;
367	}	366	}
Lines 1550-1562 Link Here
1550	return null;	1549	return null;
1551	}	1550	}
1552		1551
1553	synchronized IResolvedAnnotation resolveAnnotation(final Annotation domASTNode) {	1552	synchronized IAnnotationBinding resolveAnnotation(final Annotation domASTNode) {
1554	Object oldNode = this.newAstToOldAst.get(domASTNode);	1553	Object oldNode = this.newAstToOldAst.get(domASTNode);
1555	if (oldNode instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {	1554	if (oldNode instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
1556	org.eclipse.jdt.internal.compiler.ast.Annotation internalAstNode =	1555	org.eclipse.jdt.internal.compiler.ast.Annotation internalAstNode =
1557	(org.eclipse.jdt.internal.compiler.ast.Annotation) oldNode;	1556	(org.eclipse.jdt.internal.compiler.ast.Annotation) oldNode;
1558		1557
1559	IResolvedAnnotation domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());	1558	IAnnotationBinding domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());
1560	if (domAnnotation == null)	1559	if (domAnnotation == null)
1561	return null;	1560	return null;
1562	this.bindingsToAstNodes.put(domAnnotation, domASTNode);	1561	this.bindingsToAstNodes.put(domAnnotation, domASTNode);

Lines 330-343 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnit.java (-3 / +3 lines)
330	* This method always returns <code>null</code> when the resolved annotation	330	* This method always returns <code>null</code> when the resolved annotation
331	* comes from a different AST.	331	* comes from a different AST.
332	*	332	*
333	* @param resolvedAnnotation the resolved annotation	333	* @param annotationBinding the resolved annotation
334	* @return the corresponding node where the given resolved annotation is declared,	334	* @return the corresponding node where the given resolved annotation is declared,
335	* or <code>null</code> if the resolved annotation does not correspond to a node in this	335	* or <code>null</code> if the resolved annotation does not correspond to a node in this
336	* compilation unit or if bindings were not requested when this AST was built	336	* compilation unit or if bindings were not requested when this AST was built
337	* @since 3.2	337	* @since 3.2
338	*/	338	*/
339	public ASTNode findDeclaringNode(IResolvedAnnotation resolvedAnnotation) {	339	public ASTNode findDeclaringNode(IAnnotationBinding annotationBinding) {
340	return this.ast.getBindingResolver().findDeclaringNode(resolvedAnnotation);	340	return this.ast.getBindingResolver().findDeclaringNode(annotationBinding);
341	}	341	}
342		342
343	/**	343	/**

Lines 25-31 Link Here

(-)dom/org/eclipse/jdt/core/dom/PackageBinding.java (-15 / +14 lines)
25	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;	25	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
26	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;	26	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
27	import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;	27	import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
28	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
29	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	28	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
30	import org.eclipse.jdt.internal.core.NameLookup;	29	import org.eclipse.jdt.internal.core.NameLookup;
31	import org.eclipse.jdt.internal.core.SearchableEnvironment;	30	import org.eclipse.jdt.internal.core.SearchableEnvironment;
Lines 49-66 Link Here
49	this.resolver = resolver;	48	this.resolver = resolver;
50	}	49	}
51		50
52	public IResolvedAnnotation[] getAnnotations() {	51	public IAnnotationBinding[] getAnnotations() {
53	try {	52	try {
54	INameEnvironment nameEnvironment = this.binding.environment.nameEnvironment;	53	INameEnvironment nameEnvironment = this.binding.environment.nameEnvironment;
55	if (!(nameEnvironment instanceof SearchableEnvironment))	54	if (!(nameEnvironment instanceof SearchableEnvironment))
56	return ResolvedAnnotation.NoAnnotations;	55	return AnnotationBinding.NoAnnotations;
57	NameLookup nameLookup = ((SearchableEnvironment) nameEnvironment).nameLookup;	56	NameLookup nameLookup = ((SearchableEnvironment) nameEnvironment).nameLookup;
58	if (nameLookup == null)	57	if (nameLookup == null)
59	return ResolvedAnnotation.NoAnnotations;	58	return AnnotationBinding.NoAnnotations;
60	final String pkgName = getName();	59	final String pkgName = getName();
61	IPackageFragment[] pkgs = nameLookup.findPackageFragments(pkgName, false/exact match/);	60	IPackageFragment[] pkgs = nameLookup.findPackageFragments(pkgName, false/exact match/);
62	if (pkgs == null)	61	if (pkgs == null)
63	return ResolvedAnnotation.NoAnnotations;	62	return AnnotationBinding.NoAnnotations;
64		63
65	for (int i = 0, len = pkgs.length; i < len; i++) {	64	for (int i = 0, len = pkgs.length; i < len; i++) {
66	int fragType = pkgs[i].getKind();	65	int fragType = pkgs[i].getKind();
Lines 80-93 Link Here
80	if (pkgDecl != null) {	79	if (pkgDecl != null) {
81	List annos = pkgDecl.annotations();	80	List annos = pkgDecl.annotations();
82	if (annos == null \|\| annos.isEmpty())	81	if (annos == null \|\| annos.isEmpty())
83	return ResolvedAnnotation.NoAnnotations;	82	return AnnotationBinding.NoAnnotations;
84	IResolvedAnnotation[] result = new IResolvedAnnotation[annos.size()];	83	IAnnotationBinding[] result = new IAnnotationBinding[annos.size()];
85	int index=0;	84	int index=0;
86	for (Iterator it = annos.iterator(); it.hasNext(); index++) {	85	for (Iterator it = annos.iterator(); it.hasNext(); index++) {
87	result[index] = ((Annotation) it.next()).resolveAnnotation();	86	result[index] = ((Annotation) it.next()).resolveAnnotation();
88	// not resolving bindings	87	// not resolving bindings
89	if (result[index] == null)	88	if (result[index] == null)
90	return ResolvedAnnotation.NoAnnotations;	89	return AnnotationBinding.NoAnnotations;
91	}	90	}
92	return result;	91	return result;
93	}	92	}
Lines 99-123 Link Here
99	if (answer != null && answer.isBinaryType()) {	98	if (answer != null && answer.isBinaryType()) {
100	IBinaryType type = answer.getBinaryType();	99	IBinaryType type = answer.getBinaryType();
101	IBinaryAnnotation[] binaryAnnotations = type.getAnnotations();	100	IBinaryAnnotation[] binaryAnnotations = type.getAnnotations();
102	AnnotationBinding[] binaryInstances =	101	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] binaryInstances =
103	BinaryTypeBinding.createAnnotations(binaryAnnotations, this.binding.environment);	102	BinaryTypeBinding.createAnnotations(binaryAnnotations, this.binding.environment);
104	AnnotationBinding[] allInstances =	103	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] allInstances =
105	AnnotationBinding.addStandardAnnotations(binaryInstances, type.getTagBits(), this.binding.environment);	104	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding.addStandardAnnotations(binaryInstances, type.getTagBits(), this.binding.environment);
106	int total = allInstances.length;	105	int total = allInstances.length;
107	IResolvedAnnotation[] domInstances = new ResolvedAnnotation[total];	106	IAnnotationBinding[] domInstances = new AnnotationBinding[total];
108	for (int a = 0; a < total; a++) {	107	for (int a = 0; a < total; a++) {
109	domInstances[a] = this.resolver.getAnnotationInstance(allInstances[a]);	108	domInstances[a] = this.resolver.getAnnotationInstance(allInstances[a]);
110	if (domInstances[a] == null) // not resolving binding	109	if (domInstances[a] == null) // not resolving binding
111	return ResolvedAnnotation.NoAnnotations;	110	return AnnotationBinding.NoAnnotations;
112	}	111	}
113	return domInstances;	112	return domInstances;
114	}	113	}
115	}	114	}
116	}	115	}
117	} catch(JavaModelException e) {	116	} catch(JavaModelException e) {
118	return ResolvedAnnotation.NoAnnotations;	117	return AnnotationBinding.NoAnnotations;
119	}	118	}
120	return ResolvedAnnotation.NoAnnotations;	119	return AnnotationBinding.NoAnnotations;
121	}	120	}
122		121
123	/*	122	/*

Lines 93-105 Link Here

(-)dom/org/eclipse/jdt/core/dom/IMethodBinding.java (-3 / +3 lines)
93	* is not the binding for an annotation type member.	93	* is not the binding for an annotation type member.
94	* <p>	94	* <p>
95	* Resolved values are represented as follows (same as for	95	* Resolved values are represented as follows (same as for
96	* {@link IResolvedMemberValuePair#getValue()}):	96	* {@link IMemberValuePairBinding#getValue()}):
97	* <ul>	97	* <ul>
98	* <li>Primitive type - the equivalent boxed object</li>	98	* <li>Primitive type - the equivalent boxed object</li>
99	* <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>	99	* <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
100	* <li>java.lang.String - the string value itself</li>	100	* <li>java.lang.String - the string value itself</li>
101	* <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>	101	* <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
102	* <li>annotation type - an <code>IResolvedAnnotation</code></li>	102	* <li>annotation type - an <code>IAnnotationBinding</code></li>
103	* <li>array type - an <code>Object[]</code> whose elements are as per above	103	* <li>array type - an <code>Object[]</code> whose elements are as per above
104	* (the language only allows single dimensional arrays in annotations)</li>	104	* (the language only allows single dimensional arrays in annotations)</li>
105	* </ul>	105	* </ul>
Lines 122-128 Link Here
122	* not a valid index	122	* not a valid index
123	* @since 3.2	123	* @since 3.2
124	*/	124	*/
125	public IResolvedAnnotation[] getParameterAnnotations(int paramIndex);	125	public IAnnotationBinding[] getParameterAnnotations(int paramIndex);
126		126
127	/**	127	/**
128	* Returns a list of type bindings representing the formal parameter types,	128	* Returns a list of type bindings representing the formal parameter types,

Lines 6276-6282 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java (-3 / +3 lines)
6276	ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;	6276	ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
6277	IMethodBinding binding = classInstanceCreation.resolveConstructorBinding();	6277	IMethodBinding binding = classInstanceCreation.resolveConstructorBinding();
6278	assertNotNull("Should not be null", binding);	6278	assertNotNull("Should not be null", binding);
6279	IResolvedAnnotation[] annotations = binding.getAnnotations();	6279	IAnnotationBinding[] annotations = binding.getAnnotations();
6280	assertNotNull("Should not be null", annotations);	6280	assertNotNull("Should not be null", annotations);
6281	assertEquals("Should be empty", 0, annotations.length);	6281	assertEquals("Should be empty", 0, annotations.length);
6282	}	6282	}
Lines 6308-6315 Link Here
6308	assertEquals("Wrong size", 2, modifiers.size());	6308	assertEquals("Wrong size", 2, modifiers.size());
6309	assertTrue("Wrong type", modifiers.get(0) instanceof NormalAnnotation);	6309	assertTrue("Wrong type", modifiers.get(0) instanceof NormalAnnotation);
6310	NormalAnnotation normalAnnotation = (NormalAnnotation) modifiers.get(0);	6310	NormalAnnotation normalAnnotation = (NormalAnnotation) modifiers.get(0);
6311	IResolvedAnnotation resolvedAnnotation = normalAnnotation.resolveAnnotation();	6311	IAnnotationBinding annotationBinding = normalAnnotation.resolveAnnotation();
6312	IResolvedMemberValuePair[] pairs = resolvedAnnotation.getDeclaredMemberValuePairs();	6312	IMemberValuePairBinding[] pairs = annotationBinding.getDeclaredMemberValuePairs();
6313	assertEquals("Wrong size", 1, pairs.length);	6313	assertEquals("Wrong size", 1, pairs.length);
6314	assertNotNull("Should not be null", pairs[0].getValue());	6314	assertNotNull("Should not be null", pairs[0].getValue());
6315	}	6315	}

Lines 32-38 Link Here

(-)dom/org/eclipse/jdt/core/dom/TypeBinding.java (-5 / +4 lines)
32	import org.eclipse.jdt.internal.compiler.ast.Wildcard;	32	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
33	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	33	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
34	import org.eclipse.jdt.internal.compiler.env.IDependent;	34	import org.eclipse.jdt.internal.compiler.env.IDependent;
35	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
36	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;	35	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
37	import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;	36	import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
38	import org.eclipse.jdt.internal.compiler.lookup.Binding;	37	import org.eclipse.jdt.internal.compiler.lookup.Binding;
Lines 75-89 Link Here
75	this.resolver = resolver;	74	this.resolver = resolver;
76	}	75	}
77		76
78	public IResolvedAnnotation[] getAnnotations() {	77	public IAnnotationBinding[] getAnnotations() {
79	IResolvedAnnotation[] domInstances = ResolvedAnnotation.NoAnnotations;	78	IAnnotationBinding[] domInstances = AnnotationBinding.NoAnnotations;
80	if (this.binding.isAnnotationType() \|\| this.binding.isClass() \|\| this.binding.isEnum() \|\| this.binding.isInterface()) {	79	if (this.binding.isAnnotationType() \|\| this.binding.isClass() \|\| this.binding.isEnum() \|\| this.binding.isInterface()) {
81	org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding refType =	80	org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding refType =
82	(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding) this.binding;	81	(org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding) this.binding;
83	AnnotationBinding[] internalAnnotations = refType.getAnnotations();	82	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations = refType.getAnnotations();
84	int length = internalAnnotations == null ? 0 : internalAnnotations.length;	83	int length = internalAnnotations == null ? 0 : internalAnnotations.length;
85	if (length > 0) {	84	if (length > 0) {
86	domInstances = new ResolvedAnnotation[length];	85	domInstances = new AnnotationBinding[length];
87	for (int i = 0; i < length; i++)	86	for (int i = 0; i < length; i++)
88	domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);	87	domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);
89	}	88	}

Removed Link Here

(-)dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java (-77 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	import org.eclipse.jdt.core.dom.BindingResolver;
14	import org.eclipse.jdt.core.dom.IMethodBinding;
15	import org.eclipse.jdt.core.dom.IResolvedMemberValuePair;
16
17	/**
18	* Member value pair which compose of default values.
19	*/
20	class ResolvedDefaultValuePair implements IResolvedMemberValuePair {
21
22	private org.eclipse.jdt.internal.compiler.lookup.MethodBinding method;
23	private Object domValue;
24	private BindingResolver bindingResolver;
25
26	static void appendValue(Object value, StringBuffer buffer) {
27	if (value instanceof Object[]) {
28	Object[] values = (Object[]) value;
29	buffer.append('{');
30	for (int i = 0, l = values.length; i < l; i++) {
31	if (i != 0)
32	buffer.append(", "); //$NON-NLS-1$
33	appendValue(values[i], buffer);
34	}
35	buffer.append('}');
36	} else if (value instanceof ITypeBinding) {
37	buffer.append(((ITypeBinding) value).getName());
38	buffer.append(".class"); //$NON-NLS-1$
39	} else {
40	buffer.append(value);
41	}
42	}
43
44	ResolvedDefaultValuePair(org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding, BindingResolver resolver) {
45	this.method = binding;
46	this.domValue = ResolvedMemberValuePair.buildDOMValue(binding.getDefaultValue(), resolver);
47	this.bindingResolver = resolver;
48	}
49
50	public String getName() {
51	return new String(this.method.selector);
52	}
53
54	public IMethodBinding getMethodBinding() {
55	return this.bindingResolver.getMethodBinding(this.method);
56	}
57
58	public Object getValue() {
59	return this.domValue;
60	}
61
62	public boolean isDefault() {
63	return true;
64	}
65
66	public String toString() {
67	StringBuffer buffer = new StringBuffer();
68	toString(buffer);
69	return buffer.toString();
70	}
71
72	public void toString(StringBuffer buffer) {
73	buffer.append(getName());
74	buffer.append(" = "); //$NON-NLS-1$
75	appendValue(getValue(), buffer);
76	}
77	}

Removed Link Here

(-)dom/org/eclipse/jdt/core/dom/IResolvedMemberValuePair.java (-56 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.core.dom;
12
13	/**
14	* Represents a resolved instance of an annotation's member value pair.
15	* Resolved annotation are computed along with other bindings; these objects
16	* correspond to {@link MemberValuePair} nodes.
17	*
18	* @since 3.2
19	*/
20	public interface IResolvedMemberValuePair {
21	/**
22	* Returns the name of the annotation type member.
23	*
24	* @return the name of the member
25	*/
26	public String getName();
27
28	/**
29	* Returns the method binding corresponding to the named annotation type member.
30	*
31	* @return the method binding for the annotation type member
32	*/
33	public IMethodBinding getMethodBinding();
34
35	/**
36	* Returns the resolved value. Resolved values are represented as follows:
37	* <ul>
38	* <li>Primitive type - the equivalent boxed object</li>
39	* <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
40	* <li>java.lang.String - the string value itself</li>
41	* <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
42	* <li>annotation type - an <code>IResolvedAnnotation</code></li>
43	* <li>array type - an <code>Object[]</code> whose elements are as per above
44	* (the language only allows single dimensional arrays in annotations)</li>
45	* </ul>
46	*
47	* @return the resolved value, or <code>null</code> if none exists
48	*/
49	public Object getValue();
50
51	/**
52	* @return <code>true</code> iff this member value pair's value is the default value.
53	* Returns <code>false</code> otherwise.
54	*/
55	public boolean isDefault();
56	}

Lines 11-17 Link Here

(-)dom/org/eclipse/jdt/core/dom/BindingResolver.java (-4 / +3 lines)
11		11
12	package org.eclipse.jdt.core.dom;	12	package org.eclipse.jdt.core.dom;
13		13
14	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
15	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	14	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
16	import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;	15	import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
17	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;	16	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
Lines 105-111 Link Here
105	* @return the corresponding node where the bindings is declared,	104	* @return the corresponding node where the bindings is declared,
106	* or <code>null</code> if none	105	* or <code>null</code> if none
107	*/	106	*/
108	ASTNode findDeclaringNode(IResolvedAnnotation instance) {	107	ASTNode findDeclaringNode(IAnnotationBinding instance) {
109	return null;	108	return null;
110	}	109	}
111		110
Lines 190-196 Link Here
190	* @param instance the old annotation	189	* @param instance the old annotation
191	* @return the new DOM annotation	190	* @return the new DOM annotation
192	*/	191	*/
193	IResolvedAnnotation getAnnotationInstance(AnnotationBinding instance) {	192	IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding instance) {
194	return null;	193	return null;
195	}	194	}
196		195
Lines 830-836 Link Here
830	* @return the DOM annotation representation for the given ast node, or	829	* @return the DOM annotation representation for the given ast node, or
831	* <code>null</code> if none is available	830	* <code>null</code> if none is available
832	*/	831	*/
833	IResolvedAnnotation resolveAnnotation(Annotation annotation) {	832	IAnnotationBinding resolveAnnotation(Annotation annotation) {
834	return null;	833	return null;
835	}	834	}
836		835

Lines 68-73 Link Here

(-)dom/org/eclipse/jdt/core/dom/IBinding.java (-7 / +40 lines)
68	public static final int METHOD = 4;	68	public static final int METHOD = 4;
69		69
70	/**	70	/**
		71	* Kind constant (value 5) indicating an annotation binding.
		72	* Bindings of this kind can be safely cast to <code>IAnnotationBinding</code>.
		73	*
		74	* @see #getKind()
		75	* @see IAnnotationBinding
		76	* @since 3.2
		77	*/
		78	public static final int ANNOTATION = 5;
		79
		80	/**
		81	* Kind constant (value 6) indicating a member value pair binding.
		82	* Bindings of this kind can be safely cast to <code>IMemberValuePairBinding</code>.
		83	*
		84	* @see #getKind()
		85	* @see IMemberValuePairBinding
		86	* @since 3.2
		87	*/
		88	public static final int MEMBER_VALUE_PAIR = 6;
		89
		90	/**
71	* Return the resolved annotations associated with this binding.	91	* Return the resolved annotations associated with this binding.
72	* <ul>	92	* <ul>
73	* <li>Package bindings - these are annotations on a package declaration.	93	* <li>Package bindings - these are annotations on a package declaration.
Lines 80-101 Link Here
80	* parameterized.</li>	100	* parameterized.</li>
81	* <li>Variable bindings - these are annotations on a field, enum constant,	101	* <li>Variable bindings - these are annotations on a field, enum constant,
82	* or formal parameter declaration.</li>	102	* or formal parameter declaration.</li>
		103	* <li>Annotation bindings - an empty array is always returned</li>
		104	* <li>Member value pair bindings - an empty array is always returned<li>
83	* </ul>	105	* </ul>
84	*	106	*
85	* @return the list of resolved annotations, or the empty list if there are no	107	* @return the list of resolved annotations, or the empty list if there are no
86	* annotations associated with the object	108	* annotations associated with the object
87	* @since 3.2	109	* @since 3.2
88	*/	110	*/
89	public IResolvedAnnotation[] getAnnotations();	111	public IAnnotationBinding[] getAnnotations();
90		112
91	/**	113	/**
92	* Returns the kind of bindings this is.	114	* Returns the kind of bindings this is. That is one of the kind constants:
93	*	115	* <code>PACKAGE</code>,
94	* @return one of the kind constants:
95	* <code>PACKAGE</code>,
96	* <code>TYPE</code>,	116	* <code>TYPE</code>,
97	* <code>VARIABLE</code>,	117	* <code>VARIABLE</code>,
98	* or <code>METHOD</code>.	118	* <code>METHOD</code>,
		119	* <code>ANNOTATION</code>,
		120	* or <code>MEMBER_VALUE_PAIR</code>.
		121	* <p>
		122	* Note that additional kinds might be added in the
		123	* future, so clients should not assume this list is exhaustive and
		124	* should program defensively, e.g. by having a reasonable default
		125	* in a switch statement.
		126	* </p>
		127	* @return one of the kind constants
99	*/	128	*/
100	public int getKind();	129	public int getKind();
101		130
Lines 166-173 Link Here
166	* <li>the "length" field of an array type</li>	195	* <li>the "length" field of an array type</li>
167	* <li>the default constructor of a source class</li>	196	* <li>the default constructor of a source class</li>
168	* <li>the constructor of an anonymous class</li>	197	* <li>the constructor of an anonymous class</li>
		198	* <li>member value pairs</li>
169	* </ul>	199	* </ul>
170	* For all other kind of type, method, variable, and package bindings,	200	* For all other kind of type, method, variable, annotation and package bindings,
171	* this method returns non-<code>null</code>.	201	* this method returns non-<code>null</code>.
172	* </p>	202	* </p>
173	*	203	*
Lines 231-236 Link Here
231	* type</li>	261	* type</li>
232	* </ul>	262	* </ul>
233	* </p>	263	* </p>
		264	* <p>Note that the key for annotation bindings and member value pair bindings is
		265	* not yet implemented. This returns <code>null</code> for these 2 kinds of bindings.
		266	* </p>
234	*	267	*
235	* @return the key for this binding	268	* @return the key for this binding
236	*/	269	*/

Lines 16-22 Link Here

(-)dom/org/eclipse/jdt/core/dom/VariableBinding.java (-5 / +4 lines)
16	import org.eclipse.jdt.core.util.IModifierConstants;	16	import org.eclipse.jdt.core.util.IModifierConstants;
17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.jdt.internal.compiler.impl.Constant;	18	import org.eclipse.jdt.internal.compiler.impl.Constant;
19	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
20	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;	19	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
21	import org.eclipse.jdt.internal.compiler.lookup.TagBits;	20	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
22	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	21	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
Lines 43-54 Link Here
43	this.binding = binding;	42	this.binding = binding;
44	}	43	}
45		44
46	public IResolvedAnnotation[] getAnnotations() {	45	public IAnnotationBinding[] getAnnotations() {
47	AnnotationBinding[] internalAnnotations = this.binding.getAnnotations();	46	org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations = this.binding.getAnnotations();
48	// the variable is not an enum constant nor a field nor an argument.	47	// the variable is not an enum constant nor a field nor an argument.
49	int length = internalAnnotations == null ? 0 : internalAnnotations.length;	48	int length = internalAnnotations == null ? 0 : internalAnnotations.length;
50	IResolvedAnnotation[] domInstances =	49	IAnnotationBinding[] domInstances =
51	length == 0 ? ResolvedAnnotation.NoAnnotations : new ResolvedAnnotation[length];	50	length == 0 ? AnnotationBinding.NoAnnotations : new AnnotationBinding[length];
52	for (int i = 0; i < length; i++)	51	for (int i = 0; i < length; i++)
53	domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);	52	domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);
54	return domInstances;	53	return domInstances;

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/IAnnotationBinding.java (+66 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	* IBM Corporation - changed interface to extend IBinding
11	* IBM Corporation - renamed from IResolvedAnnotation to IAnnotationBinding
12	*******************************************************************************/
13	package org.eclipse.jdt.core.dom;
14
15	/**
16	* Represents an resolved annotation. Resolved annotation are computed along with other
17	* bindings; they correspond to {@link Annotation} nodes.
18	* <p>
19	* This interface is not intended to be implemented by clients.
20	* </p>
21	*
22	* @since 3.2
23	*/
24	public interface IAnnotationBinding extends IBinding {
25
26	/**
27	* Returns the complete list of member value pairs for this annotation, including
28	* ones explicitly listed in the annotation as well as entries for
29	* annotation type members with default values that are implied.
30	*
31	* @return a possibly empty list of resolved member value pairs
32	*/
33	IMemberValuePairBinding[] getAllMemberValuePairs();
34
35	/**
36	* Returns the type of the annotation. The resulting type binding will always
37	* return <code>true</code> to <code>ITypeBinding.isAnnotation()</code>.
38	*
39	* @return the type of the annotation
40	*/
41	ITypeBinding getAnnotationType();
42
43	/**
44	* Returns the list of declared member value pairs for this annotation.
45	* Returns an empty list for a <code>MarkerAnnotation</code>, a one element
46	* list for a <code>SingleMemberAnnotation</code>, and one entry for each
47	* of the explicitly listed values in a <code>NormalAnnotation</code>.
48	* <p>
49	* Note that the list only includes entries for annotation type members that are
50	* explicitly mentioned in the annotation. The list does not include any
51	* annotation type members with default values that are merely implied.
52	* Use {@link #getAllMemberValuePairs()} to get those as well.
53	* </p>
54	*
55	* @return a possibly empty list of resolved member value pairs
56	*/
57	IMemberValuePairBinding[] getDeclaredMemberValuePairs();
58
59	/**
60	* Returns the name of the annotation type.
61	*
62	* @return the name of the annotation type
63	*/
64	public String getName();
65
66	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/IMemberValuePairBinding.java (+61 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	* IBM Corporation - changed interface to extend IBinding
11	* IBM Corporation - renamed from IResolvedMemberValuePair to IMemberValuePairBinding
12	*******************************************************************************/
13	package org.eclipse.jdt.core.dom;
14
15	/**
16	* Represents a resolved instance of an annotation's member value pair.
17	* Resolved annotation are computed along with other bindings; these objects
18	* correspond to {@link MemberValuePair} nodes.
19	* <p>
20	* This interface is not intended to be implemented by clients.
21	* </p>
22	*
23	* @since 3.2
24	*/
25	public interface IMemberValuePairBinding extends IBinding {
26	/**
27	* Returns the name of the annotation type member.
28	*
29	* @return the name of the member
30	*/
31	public String getName();
32
33	/**
34	* Returns the method binding corresponding to the named annotation type member.
35	*
36	* @return the method binding for the annotation type member
37	*/
38	public IMethodBinding getMethodBinding();
39
40	/**
41	* Returns the resolved value. Resolved values are represented as follows:
42	* <ul>
43	* <li>Primitive type - the equivalent boxed object</li>
44	* <li>java.lang.Class - the <code>ITypeBinding</code> for the class object</li>
45	* <li>java.lang.String - the string value itself</li>
46	* <li>enum type - the <code>IVariableBinding</code> for the enum constant</li>
47	* <li>annotation type - an <code>IAnnotationBinding</code></li>
48	* <li>array type - an <code>Object[]</code> whose elements are as per above
49	* (the language only allows single dimensional arrays in annotations)</li>
50	* </ul>
51	*
52	* @return the resolved value, or <code>null</code> if none exists
53	*/
54	public Object getValue();
55
56	/**
57	* @return <code>true</code> iff this member value pair's value is the default value.
58	* Returns <code>false</code> otherwise.
59	*/
60	public boolean isDefault();
61	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultValuePairBinding.java (+123 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	* IBM Corporation - implemented methods from IBinding
11	* IBM Corporation - renamed from ResolvedDefaultValuePair to DefaultValuePairBinding
12	*******************************************************************************/
13	package org.eclipse.jdt.core.dom;
14
15	import org.eclipse.jdt.core.IJavaElement;
16	import org.eclipse.jdt.core.dom.BindingResolver;
17	import org.eclipse.jdt.core.dom.IMethodBinding;
18	import org.eclipse.jdt.core.dom.IMemberValuePairBinding;
19
20	/**
21	* Member value pair which compose of default values.
22	*/
23	class DefaultValuePairBinding implements IMemberValuePairBinding {
24
25	private org.eclipse.jdt.internal.compiler.lookup.MethodBinding method;
26	private Object domValue;
27	private BindingResolver bindingResolver;
28
29	static void appendValue(Object value, StringBuffer buffer) {
30	if (value instanceof Object[]) {
31	Object[] values = (Object[]) value;
32	buffer.append('{');
33	for (int i = 0, l = values.length; i < l; i++) {
34	if (i != 0)
35	buffer.append(", "); //$NON-NLS-1$
36	appendValue(values[i], buffer);
37	}
38	buffer.append('}');
39	} else if (value instanceof ITypeBinding) {
40	buffer.append(((ITypeBinding) value).getName());
41	buffer.append(".class"); //$NON-NLS-1$
42	} else {
43	buffer.append(value);
44	}
45	}
46
47	DefaultValuePairBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding binding, BindingResolver resolver) {
48	this.method = binding;
49	this.domValue = MemberValuePairBinding.buildDOMValue(binding.getDefaultValue(), resolver);
50	this.bindingResolver = resolver;
51	}
52
53	public IAnnotationBinding[] getAnnotations() {
54	return AnnotationBinding.NoAnnotations;
55	}
56
57	public IJavaElement getJavaElement() {
58	return null;
59	}
60
61	public String getKey() {
62	// TODO when implementing, update spec in IBinding
63	return null;
64	}
65
66	public int getKind() {
67	return IBinding.MEMBER_VALUE_PAIR;
68	}
69
70	public IMethodBinding getMethodBinding() {
71	return this.bindingResolver.getMethodBinding(this.method);
72	}
73
74	public int getModifiers() {
75	return -1;
76	}
77
78	public String getName() {
79	return new String(this.method.selector);
80	}
81
82	public Object getValue() {
83	return this.domValue;
84	}
85
86	public boolean isDefault() {
87	return true;
88	}
89
90	public boolean isDeprecated() {
91	return false;
92	}
93
94	public boolean isEqualTo(IBinding binding) {
95	if (this == binding)
96	return true;
97	if (binding.getKind() != IBinding.MEMBER_VALUE_PAIR)
98	return false;
99	IMemberValuePairBinding other = (IMemberValuePairBinding) binding;
100	if (!getMethodBinding().isEqualTo(other.getMethodBinding()))
101	return false;
102	Object value = getValue();
103	if (value == null)
104	return other.getValue() == null;
105	return value.equals(other.getValue());
106	}
107
108	public boolean isSynthetic() {
109	return false;
110	}
111
112	public String toString() {
113	StringBuffer buffer = new StringBuffer();
114	toString(buffer);
115	return buffer.toString();
116	}
117
118	public void toString(StringBuffer buffer) {
119	buffer.append(getName());
120	buffer.append(" = "); //$NON-NLS-1$
121	appendValue(getValue(), buffer);
122	}
123	}

Added Link Here

(-)dom/org/eclipse/jdt/core/dom/MemberValuePairBinding.java (+164 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 BEA Systems, Inc.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* tyeung@bea.com - initial API and implementation
10	* IBM Corporation - implemented methods from IBinding
11	* IBM Corporation - renamed from ResolvedMemberValuePair to MemberValuePairBinding
12	*******************************************************************************/
13	package org.eclipse.jdt.core.dom;
14
15	import org.eclipse.jdt.core.IJavaElement;
16	import org.eclipse.jdt.internal.compiler.impl.Constant;
17	import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
18	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
19
20	/**
21	* Internal class.
22	*/
23	class MemberValuePairBinding implements IMemberValuePairBinding {
24	static final MemberValuePairBinding[] NoPair = new MemberValuePairBinding[0];
25	private static final Object NoValue = new Object();
26	private static final Object[] EmptyArray = new Object[0];
27
28	private ElementValuePair internalPair;
29	private Object value = null;
30	private BindingResolver bindingResolver;
31
32	static Object buildDOMValue(final Object internalObject, BindingResolver resolver) {
33	if (internalObject == null)
34	return null;
35
36	if (internalObject instanceof Constant) {
37	Constant constant = (Constant) internalObject;
38	switch (constant.typeID()) {
39	case TypeIds.T_boolean:
40	return Boolean.valueOf(constant.booleanValue());
41	case TypeIds.T_byte:
42	return new Byte(constant.byteValue());
43	case TypeIds.T_char:
44	return new Character(constant.charValue());
45	case TypeIds.T_double:
46	return new Double(constant.doubleValue());
47	case TypeIds.T_float:
48	return new Float(constant.floatValue());
49	case TypeIds.T_int:
50	return new Integer(constant.intValue());
51	case TypeIds.T_long:
52	return new Long(constant.longValue());
53	case TypeIds.T_short:
54	return new Short(constant.shortValue());
55	case TypeIds.T_JavaLangString:
56	return constant.stringValue();
57	}
58	} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.TypeBinding) {
59	return resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) internalObject);
60	} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding) {
61	return resolver.getAnnotationInstance((org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding) internalObject);
62	} else if (internalObject instanceof org.eclipse.jdt.internal.compiler.lookup.FieldBinding) {
63	return resolver.getVariableBinding((org.eclipse.jdt.internal.compiler.lookup.FieldBinding) internalObject);
64	} else if (internalObject instanceof Object[]) {
65	Object[] elements = (Object[]) internalObject;
66	int length = elements.length;
67	Object[] values = length == 0 ? EmptyArray : new Object[length];
68	for (int i = 0; i < length; i++)
69	values[i] = buildDOMValue(elements[i], resolver);
70	return values;
71	}
72	throw new IllegalStateException(internalObject.toString()); // should never get here
73	}
74
75	MemberValuePairBinding(ElementValuePair pair, BindingResolver resolver) {
76	this.internalPair = pair;
77	this.bindingResolver = resolver;
78	}
79
80	public IAnnotationBinding[] getAnnotations() {
81	return AnnotationBinding.NoAnnotations;
82	}
83
84	public IJavaElement getJavaElement() {
85	return null;
86	}
87
88	public String getKey() {
89	// TODO when implementing, update spec in IBinding
90	return null;
91	}
92
93	public int getKind() {
94	return IBinding.MEMBER_VALUE_PAIR;
95	}
96
97	public IMethodBinding getMethodBinding() {
98	return this.bindingResolver.getMethodBinding(this.internalPair.getMethodBinding());
99	}
100
101	public int getModifiers() {
102	return -1;
103	}
104
105	public String getName() {
106	if (this.internalPair == null)
107	return null;
108	final char[] membername = this.internalPair.getName();
109	return membername == null ? null : new String(membername);
110	}
111
112	public Object getValue() {
113	if (value == null)
114	init();
115	return value == NoValue ? null : this.value;
116	}
117
118	private void init() {
119	this.value = buildDOMValue(this.internalPair.getValue(), this.bindingResolver);
120	if (this.value == null)
121	this.value = NoValue;
122	}
123
124	char[] internalName() {
125	return this.internalPair == null ? null : this.internalPair.getName();
126	}
127
128	public boolean isDefault() {
129	return false;
130	}
131
132	public boolean isDeprecated() {
133	return false;
134	}
135
136	public boolean isEqualTo(IBinding binding) {
137	if (this == binding)
138	return true;
139	if (binding.getKind() != IBinding.MEMBER_VALUE_PAIR)
140	return false;
141	IMemberValuePairBinding other = (IMemberValuePairBinding) binding;
142	if (!getMethodBinding().isEqualTo(other.getMethodBinding()))
143	return false;
144	if (this.value == null)
145	return other.getValue() == null;
146	return this.value.equals(other.getValue());
147	}
148
149	public boolean isSynthetic() {
150	return false;
151	}
152
153	public String toString() {
154	StringBuffer buffer = new StringBuffer();
155	toString(buffer);
156	return buffer.toString();
157	}
158
159	public void toString(StringBuffer buffer) {
160	buffer.append(getName());
161	buffer.append(" = "); //$NON-NLS-1$
162	DefaultValuePairBinding.appendValue(getValue(), buffer);
163	}
164	}