diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/ASTBasedDeclarationImpl.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/ASTBasedDeclarationImpl.java
index a478285..56f8a07 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/ASTBasedDeclarationImpl.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/ASTBasedDeclarationImpl.java
@@ -22,7 +22,7 @@
 import org.eclipse.jdt.core.dom.BodyDeclaration;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.IExtendedModifier;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 import org.eclipse.jdt.core.dom.VariableDeclaration;
 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
@@ -111,19 +111,19 @@
 	
 	public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
     {
-		final IResolvedAnnotation[] instances = getAnnotationInstancesFromAST();
+		final IAnnotationBinding[] instances = getAnnotationInstancesFromAST();
 		return _getAnnotation(annotationClass, instances);
     }
 
     public Collection<AnnotationMirror> getAnnotationMirrors()
     {
-		final IResolvedAnnotation[] instances = getAnnotationInstancesFromAST();
+		final IAnnotationBinding[] instances = getAnnotationInstancesFromAST();
 		return _getAnnotationMirrors(instances);		
     }
 	
-	private IResolvedAnnotation[] getAnnotationInstancesFromAST()
+	private IAnnotationBinding[] getAnnotationInstancesFromAST()
 	{	
-		IResolvedAnnotation[] instances = null;
+		IAnnotationBinding[] instances = null;
 		List extendsMods = null;
 		switch( _astNode.getNodeType() )
 		{
@@ -156,13 +156,13 @@
 				if( extMod.isAnnotation() )
 					count ++;
 			}
-			instances = new IResolvedAnnotation[count];
+			instances = new IAnnotationBinding[count];
 			int index = 0;
 			for( Object obj : extendsMods ){
 				final IExtendedModifier extMod = (IExtendedModifier)obj;
 				if( extMod.isAnnotation() )
 					instances[index ++] = 
-						((org.eclipse.jdt.core.dom.Annotation)extMod).resolveAnnotation();
+						((org.eclipse.jdt.core.dom.Annotation)extMod).resolveAnnotationBinding();
 			}
 		}
 		return instances;
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/AnnotationMirrorImpl.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/AnnotationMirrorImpl.java
index e66b46f..cf1b9aa 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/AnnotationMirrorImpl.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/AnnotationMirrorImpl.java
@@ -25,8 +25,8 @@
 import org.eclipse.jdt.core.dom.Annotation;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.IMethodBinding;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
-import org.eclipse.jdt.core.dom.IResolvedMemberValuePair;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
+import org.eclipse.jdt.core.dom.IMemberValuePairBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.dom.MemberValuePair;
@@ -46,13 +46,13 @@
 public class AnnotationMirrorImpl implements AnnotationMirror, EclipseMirrorImpl
 {
     /**The ast node that correspond to the annotation.*/
-    private final IResolvedAnnotation _domAnnotation;
+    private final IAnnotationBinding _domAnnotation;
     private final BaseProcessorEnv _env;
     /** the declaration that is annotated by this annotation or the annotation element declaration
      *  if this is (part of) a default value*/
     private final EclipseDeclarationImpl _annotated;
     
-    public AnnotationMirrorImpl(IResolvedAnnotation annotationAstNode, EclipseDeclarationImpl decl, BaseProcessorEnv env)
+    public AnnotationMirrorImpl(IAnnotationBinding annotationAstNode, EclipseDeclarationImpl decl, BaseProcessorEnv env)
     {
 		_domAnnotation = annotationAstNode;
         _env = env;
@@ -80,14 +80,14 @@
 
     public Map<AnnotationTypeElementDeclaration, AnnotationValue> getElementValues()
     {
-		final IResolvedMemberValuePair[] pairs = _domAnnotation.getDeclaredMemberValuePairs();
+		final IMemberValuePairBinding[] pairs = _domAnnotation.getDeclaredMemberValuePairs();
 		if (pairs.length == 0) {
 			return Collections.emptyMap();
 		}
 		
 		final Map<AnnotationTypeElementDeclaration, AnnotationValue> result =
 			new LinkedHashMap<AnnotationTypeElementDeclaration, AnnotationValue>(pairs.length * 4 / 3 + 1 );
-		for( IResolvedMemberValuePair pair : pairs ){
+		for( IMemberValuePairBinding pair : pairs ){
 			 final String name = pair.getName();
              if( name == null ) continue;
              IMethodBinding elementMethod = pair.getMethodBinding();            
@@ -142,8 +142,8 @@
     public ITypeBinding[] getMemberValueTypeBinding(String membername)
     {
         if( membername == null ) return null;
-		final IResolvedMemberValuePair[] declaredPairs = _domAnnotation.getDeclaredMemberValuePairs();
-		for( IResolvedMemberValuePair pair : declaredPairs ){			
+		final IMemberValuePairBinding[] declaredPairs = _domAnnotation.getDeclaredMemberValuePairs();
+		for( IMemberValuePairBinding pair : declaredPairs ){			
 			if( membername.equals(pair.getName()) ){
 				final Object value = pair.getValue();
 				return getValueTypeBinding(value, pair.getMethodBinding().getReturnType());
@@ -191,8 +191,8 @@
     public Object getValue(final String memberName)
     {
 		if( memberName == null ) return null;
-		final IResolvedMemberValuePair[] declaredPairs = _domAnnotation.getDeclaredMemberValuePairs();
-		for( IResolvedMemberValuePair pair : declaredPairs ){			
+		final IMemberValuePairBinding[] declaredPairs = _domAnnotation.getDeclaredMemberValuePairs();
+		for( IMemberValuePairBinding pair : declaredPairs ){			
 			if( memberName.equals(pair.getName()) ){
 				return pair.getValue();				
 			}
@@ -221,7 +221,7 @@
         return null;
     }
     
-    public IResolvedAnnotation getResolvedAnnotaion(){return _domAnnotation; }
+    public IAnnotationBinding getResolvedAnnotaion(){return _domAnnotation; }
 
     
 
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/BinaryParameterDeclarationImpl.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/BinaryParameterDeclarationImpl.java
index f499f60..8fd6120 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/BinaryParameterDeclarationImpl.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/BinaryParameterDeclarationImpl.java
@@ -28,7 +28,7 @@
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
@@ -101,14 +101,14 @@
     public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
     {
 		final IMethodBinding methodBinding = _executable.getDeclarationBinding();
-		final IResolvedAnnotation[] paramAnnos = methodBinding.getParameterAnnotations(_paramIndex); 
+		final IAnnotationBinding[] paramAnnos = methodBinding.getParameterAnnotations(_paramIndex); 
         return _getAnnotation(annotationClass, paramAnnos);
     }
 
     public Collection<AnnotationMirror> getAnnotationMirrors()
     {
 		final IMethodBinding methodBinding = _executable.getDeclarationBinding();
-		final IResolvedAnnotation[] paramAnnos = methodBinding.getParameterAnnotations(_paramIndex); 
+		final IAnnotationBinding[] paramAnnos = methodBinding.getParameterAnnotations(_paramIndex); 
         return _getAnnotationMirrors(paramAnnos);
     }    
     
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/EclipseDeclarationImpl.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/EclipseDeclarationImpl.java
index ab72d1c..e687857 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/EclipseDeclarationImpl.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/EclipseDeclarationImpl.java
@@ -30,7 +30,7 @@
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
 import org.eclipse.jdt.core.dom.FieldDeclaration;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.Javadoc;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
@@ -58,7 +58,7 @@
     }        
 
     <A extends Annotation> A _getAnnotation(Class<A> annotationClass,
-                                            IResolvedAnnotation[] annoInstances)
+                                            IAnnotationBinding[] annoInstances)
     {
     	if( annoInstances == null || annoInstances.length == 0 || annotationClass == null ) 
     		return null;
@@ -68,7 +68,7 @@
         annoTypeName = annoTypeName.replace('$', '.');
 		final int len = annoInstances == null ? 0 : annoInstances.length;
         if( len == 0 ) return null;
-        for( IResolvedAnnotation annoInstance :  annoInstances){
+        for( IAnnotationBinding annoInstance :  annoInstances){
             final ITypeBinding binding = annoInstance.getAnnotationType();            
             if( binding != null && binding.isAnnotation() ){
                 final String curTypeName = binding.getQualifiedName();
@@ -84,12 +84,12 @@
         return null; 
     }
 
-    Collection<AnnotationMirror> _getAnnotationMirrors(IResolvedAnnotation[] annoInstances)
+    Collection<AnnotationMirror> _getAnnotationMirrors(IAnnotationBinding[] annoInstances)
     {
 		final int len = annoInstances == null ? 0 : annoInstances.length;
         if( len == 0 ) return Collections.emptyList();
         final List<AnnotationMirror> result = new ArrayList<AnnotationMirror>(len);
-        for(IResolvedAnnotation annoInstance : annoInstances){
+        for(IAnnotationBinding annoInstance : annoInstances){
             final AnnotationMirrorImpl annoMirror =
                         (AnnotationMirrorImpl)Factory.createAnnotationMirror(annoInstance, this, _env);
             result.add(annoMirror);
@@ -103,7 +103,7 @@
 		final List<AnnotationMirror> result = new ArrayList<AnnotationMirror>(annoInstances.size());
 		for( org.eclipse.jdt.core.dom.Annotation annoInstance : annoInstances){
 			final AnnotationMirrorImpl annoMirror =
-				(AnnotationMirrorImpl)Factory.createAnnotationMirror(annoInstance.resolveAnnotation(), this, _env);
+				(AnnotationMirrorImpl)Factory.createAnnotationMirror(annoInstance.resolveAnnotationBinding(), this, _env);
 			result.add(annoMirror);
 		}
 		return result;
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/MemberDeclarationImpl.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/MemberDeclarationImpl.java
index 32b5c19..47d7d17 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/MemberDeclarationImpl.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/declaration/MemberDeclarationImpl.java
@@ -38,20 +38,20 @@
     
     public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
     {
-		final IResolvedAnnotation[] instances = getAnnotationInstances();
+		final IAnnotationBinding[] instances = getAnnotationInstances();
 		return _getAnnotation(annotationClass, instances);
     }
 
     public Collection<AnnotationMirror> getAnnotationMirrors()
     {
-		final IResolvedAnnotation[] instances = getAnnotationInstances();
+		final IAnnotationBinding[] instances = getAnnotationInstances();
 		return _getAnnotationMirrors(instances);		
     }
 	
-	private IResolvedAnnotation[] getAnnotationInstances()
+	private IAnnotationBinding[] getAnnotationInstances()
 	{
 		final IBinding binding = getDeclarationBinding();
-		final IResolvedAnnotation[] instances;
+		final IAnnotationBinding[] instances;
 		switch( binding.getKind() )
 		{
 		case IBinding.TYPE:
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AnnotationInvocationHandler.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AnnotationInvocationHandler.java
index 606afaa..a05cecb 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AnnotationInvocationHandler.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AnnotationInvocationHandler.java
@@ -26,7 +26,7 @@
 import org.eclipse.jdt.apt.core.internal.declaration.AnnotationMirrorImpl;
 import org.eclipse.jdt.apt.core.internal.util.Factory;
 import org.eclipse.jdt.core.dom.IMethodBinding;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 
@@ -195,11 +195,11 @@
 	    else if( domValue instanceof ITypeBinding )
 			throw new IllegalStateException("sourceValue is a type binding."); //$NON-NLS-1$
 		
-	    else if( domValue instanceof IResolvedAnnotation )
+	    else if( domValue instanceof IAnnotationBinding )
 		{
 			final AnnotationMirrorImpl annoMirror = 
 				(AnnotationMirrorImpl)Factory.createAnnotationMirror(
-					(IResolvedAnnotation)domValue, 
+					(IAnnotationBinding)domValue, 
 					_instance.getAnnotatedDeclaration(), 
 					_instance.getEnvironment());
 	        final AnnotationInvocationHandler handler = new AnnotationInvocationHandler(annoMirror, expectedType);
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/Factory.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/Factory.java
index e7f18f8..710a0c5 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/Factory.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/Factory.java
@@ -55,7 +55,7 @@
 import org.eclipse.jdt.apt.core.internal.type.WildcardTypeImpl;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
@@ -221,7 +221,7 @@
      * @param env
      * @return a newly created {@link AnnotationMirror} object
      */
-    public static AnnotationMirror createAnnotationMirror(final IResolvedAnnotation annotation,
+    public static AnnotationMirror createAnnotationMirror(final IAnnotationBinding annotation,
                                                           final EclipseDeclarationImpl annotated,
                                                           final BaseProcessorEnv env)
     {
@@ -366,7 +366,7 @@
 				Object o = convertDOMValueToMirrorValue( elements[i], name, parent, decl, env, leaf );				
 				if( o == null ) 
 					return null; 
-				assert( !( o instanceof IResolvedAnnotation ) ) : 
+				assert( !( o instanceof IAnnotationBinding ) ) : 
 					"Unexpected return value from convertDomValueToMirrorValue! o.getClass().getName() = " //$NON-NLS-1$
 					+ o.getClass().getName(); 
 				
@@ -380,9 +380,9 @@
         else if( domValue instanceof ITypeBinding )
 			returnValue = Factory.createTypeMirror((ITypeBinding)domValue, env);
 		
-        else if( domValue instanceof IResolvedAnnotation )
+        else if( domValue instanceof IAnnotationBinding )
 		{
-			returnValue = Factory.createAnnotationMirror((IResolvedAnnotation)domValue, decl, env);
+			returnValue = Factory.createAnnotationMirror((IAnnotationBinding)domValue, decl, env);
 		}
         else	        
 			// should never reach this point
diff --git a/org.eclipse.jdt.apt.tests/src/org/eclipse/jdt/apt/tests/ReadAnnotationTests2.java b/org.eclipse.jdt.apt.tests/src/org/eclipse/jdt/apt/tests/ReadAnnotationTests2.java
index 6436864..7030d7e 100644
--- a/org.eclipse.jdt.apt.tests/src/org/eclipse/jdt/apt/tests/ReadAnnotationTests2.java
+++ b/org.eclipse.jdt.apt.tests/src/org/eclipse/jdt/apt/tests/ReadAnnotationTests2.java
@@ -21,7 +21,7 @@
 import org.eclipse.jdt.core.dom.ASTRequestor;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
-import org.eclipse.jdt.core.dom.IResolvedAnnotation;
+import org.eclipse.jdt.core.dom.IAnnotationBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.tests.builder.Tests;
@@ -307,7 +307,7 @@
 		}
 	}
 	
-	private void assertAnnotation(final String[] expected, IResolvedAnnotation[] annotations)
+	private void assertAnnotation(final String[] expected, IAnnotationBinding[] annotations)
 	{
 		final int expectedLen = expected.length;		
 		TestCase.assertEquals("annotation number mismatch", expected.length, annotations.length); //$NON-NLS-1$
@@ -317,7 +317,7 @@
 			expectedSet.add(expected[i]);
 			
 		int counter = 0;
-		for( IResolvedAnnotation mirror : annotations ){
+		for( IAnnotationBinding mirror : annotations ){
 			if( counter >= expectedLen )
 				TestCase.assertEquals("", mirror.toString()); //$NON-NLS-1$
 			else{
diff --git a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
index 61fa790..dfc7c1d 100644
--- a/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
+++ b/org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java
@@ -368,7 +368,7 @@
 						ITypeBinding typeBinding = typeDecl.resolveBinding();
 						if (typeBinding == null) continue;
 						typeBinding = typeBinding.getAnnotations()[0].getAnnotationType();
-						IResolvedAnnotation targetValue = typeBinding.getAnnotations()[0];
+						IAnnotationBinding targetValue = typeBinding.getAnnotations()[0];
 						IMethodBinding method = targetValue.getDeclaredMemberValuePairs()[0].getMethodBinding();
 						if (!"value".equals(method.getName()))
 							problems.add(new ParticipantProblem("method " + method.getName() + " not found", file.getName()));
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
index 0f85d4d..60d04a6 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java
@@ -6276,7 +6276,7 @@
 		ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
 		IMethodBinding binding = classInstanceCreation.resolveConstructorBinding();
 		assertNotNull("Should not be null", binding);
-		IResolvedAnnotation[] annotations = binding.getAnnotations();
+		IAnnotationBinding[] annotations = binding.getAnnotations();
 		assertNotNull("Should not be null", annotations);
 		assertEquals("Should be empty", 0, annotations.length);
 	}
@@ -6308,8 +6308,8 @@
 		assertEquals("Wrong size", 2, modifiers.size());
 		assertTrue("Wrong type", modifiers.get(0) instanceof NormalAnnotation);
 		NormalAnnotation normalAnnotation = (NormalAnnotation) modifiers.get(0);
-		IResolvedAnnotation resolvedAnnotation = normalAnnotation.resolveAnnotation();
-		IResolvedMemberValuePair[] pairs = resolvedAnnotation.getDeclaredMemberValuePairs();
+		IAnnotationBinding annotationBinding = normalAnnotation.resolveAnnotationBinding();
+		IMemberValuePairBinding[] pairs = annotationBinding.getDeclaredMemberValuePairs();
 		assertEquals("Wrong size", 1, pairs.length);
 		assertNotNull("Should not be null", pairs[0].getValue());
 	}
diff --git a/org.eclipse.jdt.core/buildnotes_jdt-core.html b/org.eclipse.jdt.core/buildnotes_jdt-core.html
index 87361e7..e23ce9e 100644
--- a/org.eclipse.jdt.core/buildnotes_jdt-core.html
+++ b/org.eclipse.jdt.core/buildnotes_jdt-core.html
@@ -70,7 +70,9 @@
 </ul>
 
 <h3>Problem Reports Fixed</h3>
-<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=108539">108539</a>
+<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=123470">123470</a>
+AST: new type IResolvedAnnotation
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=108539">108539</a>
 Error popup at breakpoint in tomcat project
 <br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=99006">99006</a>
 Incorrect warning when a non-varargs method overrides a varargs method.
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
index 6093674..7d2446f 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
@@ -2025,7 +2025,7 @@
 		markerAnnotation.setSourceRange(start, end - start + 1);
 		if (this.resolveBindings) {
 			recordNodes(markerAnnotation, annotation);
-			markerAnnotation.resolveAnnotation();
+			markerAnnotation.resolveAnnotationBinding();
 		}
 		return markerAnnotation;
 	}
@@ -2088,7 +2088,7 @@
 		normalAnnotation.setSourceRange(start, end - start + 1);
 		if (this.resolveBindings) {
 			recordNodes(normalAnnotation, annotation);
-			normalAnnotation.resolveAnnotation();
+			normalAnnotation.resolveAnnotationBinding();
 		}
 		return normalAnnotation;
 	}
@@ -2328,7 +2328,7 @@
 		singleMemberAnnotation.setSourceRange(start, end - start + 1);
 		if (this.resolveBindings) {
 			recordNodes(singleMemberAnnotation, annotation);
-			singleMemberAnnotation.resolveAnnotation();
+			singleMemberAnnotation.resolveAnnotationBinding();
 		}
 		return singleMemberAnnotation;
 	}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Annotation.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Annotation.java
index 0dd8c13..eadd659 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Annotation.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Annotation.java
@@ -175,7 +175,7 @@
 	 * @return the resolved annotation, or <code>null</code> if the annotation cannot be resolved
 	 * @since 3.2
 	 */	
-	public IResolvedAnnotation resolveAnnotation() {
+	public IAnnotationBinding resolveAnnotationBinding() {
 	    return this.ast.getBindingResolver().resolveAnnotation(this);
 	}
 }
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java
new file mode 100644
index 0000000..65c0228
--- /dev/null
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AnnotationBinding.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * 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] = this.bindingResolver.getMemberValuePairBinding(internalPairs[i]);
+		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();
+	}
+	
+}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/BindingResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/BindingResolver.java
index 3041f88..426a625 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/BindingResolver.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/BindingResolver.java
@@ -11,9 +11,9 @@
 
 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.ElementValuePair;
 import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
 
 /**
@@ -105,7 +105,7 @@
 	 * @return the corresponding node where the bindings is declared, 
 	 *    or <code>null</code> if none
 	 */
-	ASTNode findDeclaringNode(IResolvedAnnotation instance) {
+	ASTNode findDeclaringNode(IAnnotationBinding instance) {
 		return null;
 	}
 
@@ -137,6 +137,20 @@
 	IMethodBinding getMethodBinding(org.eclipse.jdt.internal.compiler.lookup.MethodBinding methodBinding) {
 		return null;
 	}
+	
+	/**
+	 * Returns the new member value pair binding corresponding to the given old value pair binding.
+	 * <p>
+	 * The default implementation of this method returns <code>null</code>.
+	 * Subclasses may reimplement.
+	 * </p>
+	 * 
+	 * @param valuePair the old value pair binding
+	 * @return the new member value pair binding
+	 */
+	IMemberValuePairBinding getMemberValuePairBinding(ElementValuePair valuePair) {
+		return null;
+	}
 
 	/**
 	 * Returns the new package binding corresponding to the given old package binding.
@@ -190,7 +204,7 @@
 	 * @param instance the old annotation 
 	 * @return the new DOM annotation
 	 */
-	IResolvedAnnotation getAnnotationInstance(AnnotationBinding instance) {
+	IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding instance) {
 		return null;
 	}
 
@@ -818,7 +832,7 @@
 	/**
 	 * Resolves the given annotation instance and returns the DOM representation for it.
 	 * <p>
-	 * The implementation of {@link Annotation#resolveAnnotation()}
+	 * The implementation of {@link Annotation#resolveAnnotationBinding()}
 	 * forwards to this method. 
 	 * </p>
 	 * <p>
@@ -830,7 +844,7 @@
 	 * @return the DOM annotation representation for the given ast node, or 
 	 *    <code>null</code> if none is available
 	 */
-	IResolvedAnnotation resolveAnnotation(Annotation annotation) {
+	IAnnotationBinding resolveAnnotation(Annotation annotation) {
 		return null;
 	}
 
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java
index b7b11b1..5c69677 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnit.java
@@ -298,6 +298,8 @@
      * <li>enum constant - an <code>EnumConstantDeclaration</code></li>
      * <li>type variable - a <code>TypeParameter</code></li>
      * <li>capture binding - none</li>
+     * <li>annotation binding - an <code>Annotation</code></li>
+     * <li>member value pair binding - an <code>MemberValuePair</code></li>
 	 * </ul>
      * For parameterized or raw type bindings, the declaring node is
      * that of the corresponding generic type. And for parameterized or raw
@@ -324,24 +326,6 @@
 	
 	/**
 	 * Finds the corresponding AST node in the given compilation unit from 
-	 * which the given resolved annotation originated. Returns <code>null</code>
-	 * if the resolved annotation does not correspond to any node in this compilation unit.
-	 *
-	 * This method always returns <code>null</code> when the resolved annotation
-	 * comes from a different AST.
-	 * 
-	 * @param resolvedAnnotation 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(IResolvedAnnotation resolvedAnnotation) {
-		return this.ast.getBindingResolver().findDeclaringNode(resolvedAnnotation);
-	}
-
-	/**
-	 * Finds the corresponding AST node in the given compilation unit from 
 	 * which the binding with the given key originated. Returns
 	 * <code>null</code> if the corresponding node cannot be determined.
 	 * This method always returns <code>null</code> if bindings were not requested
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
index 7880a6c..9f22de6 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
@@ -43,11 +43,11 @@
 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;
 import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
+import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
 import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
 import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
 import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
@@ -178,7 +178,7 @@
 		return (ASTNode) this.bindingsToAstNodes.get(binding);
 	}
 
-	synchronized ASTNode findDeclaringNode(IResolvedAnnotation instance) {
+	synchronized ASTNode findDeclaringNode(IAnnotationBinding instance) {
 		if (instance == null)
 			return null;
 		return (ASTNode) this.bindingsToAstNodes.get(instance);
@@ -250,6 +250,18 @@
 		}
 		return null;
 	}
+	
+	synchronized IMemberValuePairBinding getMemberValuePairBinding(ElementValuePair valuePair) {
+		if (valuePair == null) return null;
+		IMemberValuePairBinding binding = 
+			(IMemberValuePairBinding) this.bindingTables.compilerBindingsToASTBindings.get(valuePair);
+		if (binding != null)
+			return binding;
+		binding = new MemberValuePairBinding(valuePair, this);
+		this.bindingTables.compilerBindingsToASTBindings.put(valuePair, binding);
+		return binding;
+	}
+
 	/*
 	 * Method declared on BindingResolver.
 	 */
@@ -355,13 +367,13 @@
 		return null;
 	}
 	
-	synchronized IResolvedAnnotation getAnnotationInstance(AnnotationBinding internalInstance) {
+	synchronized IAnnotationBinding getAnnotationInstance(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalInstance) {
 		if (internalInstance == null) return null;
-		IResolvedAnnotation domInstance = 
-			(IResolvedAnnotation) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);
+		IAnnotationBinding domInstance = 
+			(IAnnotationBinding) this.bindingTables.compilerBindingsToASTBindings.get(internalInstance);
 		if (domInstance != null)
 			return domInstance;
-		domInstance = new ResolvedAnnotation(internalInstance, this);
+		domInstance = new AnnotationBinding(internalInstance, this);
 		this.bindingTables.compilerBindingsToASTBindings.put(internalInstance, domInstance);
 		return domInstance;
 	}
@@ -1550,13 +1562,13 @@
 		return null;
 	}
 
-	synchronized IResolvedAnnotation resolveAnnotation(final Annotation domASTNode) {
+	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;
 			
-			IResolvedAnnotation domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());
+			IAnnotationBinding domAnnotation = this.getAnnotationInstance(internalAstNode.getCompilerAnnotation());
 			if (domAnnotation == null)
 				return null;
 			this.bindingsToAstNodes.put(domAnnotation, domASTNode);			
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultValuePairBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultValuePairBinding.java
new file mode 100644
index 0000000..07efa1f
--- /dev/null
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultValuePairBinding.java
@@ -0,0 +1,123 @@
+/*******************************************************************************
+ * 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);
+	}
+}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IAnnotationBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IAnnotationBinding.java
new file mode 100644
index 0000000..ec25eba
--- /dev/null
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IAnnotationBinding.java
@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * 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();
+	
+}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IBinding.java
index 6b04678..c9e82c1 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IBinding.java
@@ -68,6 +68,26 @@
 	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.
@@ -80,22 +100,31 @@
 	 * 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 IResolvedAnnotation[] getAnnotations();
+	public IAnnotationBinding[] getAnnotations();
 
 	/**
-	 * Returns the kind of bindings this is.
-	 * 
-	 * @return one of the kind constants:
-	 * 	<code>PACKAGE</code>,
+	 * Returns the kind of bindings this is. That is one of the kind constants:
+	 * <code>PACKAGE</code>,
 	 * 	<code>TYPE</code>,
 	 * 	<code>VARIABLE</code>,
-	 * 	or <code>METHOD</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();
 	
@@ -166,8 +195,9 @@
 	 * <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, and package bindings,
+	 * For all other kind of type, method, variable, annotation and package bindings,
 	 * this method returns non-<code>null</code>.
 	 * </p>
 	 * 
@@ -231,6 +261,9 @@
 	 * 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
 	 */
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedMemberValuePair.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMemberValuePairBinding.java
similarity index 84%
rename from org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedMemberValuePair.java
rename to org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMemberValuePairBinding.java
index 2096e0b..aedaf01 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedMemberValuePair.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMemberValuePairBinding.java
@@ -7,6 +7,8 @@
  *
  * 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;
 
@@ -14,10 +16,13 @@
  * 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 IResolvedMemberValuePair {
+public interface IMemberValuePairBinding extends IBinding {
 /**
  * Returns the name of the annotation type member.
  * 
@@ -39,7 +44,7 @@
  * <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>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>
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMethodBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMethodBinding.java
index 85a8b7c..76cf967 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMethodBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IMethodBinding.java
@@ -93,13 +93,13 @@
 	 * is not the binding for an annotation type member.
 	 * <p>
 	 * Resolved values are represented as follows (same as for
-	 * {@link IResolvedMemberValuePair#getValue()}):
+	 * {@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>IResolvedAnnotation</code></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>
@@ -122,7 +122,7 @@
 	 * not a valid index
 	 * @since 3.2
 	 */
-	public IResolvedAnnotation[] getParameterAnnotations(int paramIndex);
+	public IAnnotationBinding[] getParameterAnnotations(int paramIndex);
 
 	/**
 	 * Returns a list of type bindings representing the formal parameter types,
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedAnnotation.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedAnnotation.java
deleted file mode 100644
index 3eadc38..0000000
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/IResolvedAnnotation.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*******************************************************************************
- * 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();
-}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePairBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePairBinding.java
new file mode 100644
index 0000000..b68f4eb
--- /dev/null
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MemberValuePairBinding.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * 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);
+	}
+}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
index 6ca9875..ce75a1a 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/MethodBinding.java
@@ -20,7 +20,6 @@
 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;
@@ -102,12 +101,12 @@
 		return name;
 	}
 
-	public IResolvedAnnotation[] getAnnotations() { 
-		AnnotationBinding[] annotations = this.binding.getAnnotations();
+	public IAnnotationBinding[] getAnnotations() { 
+		org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] annotations = this.binding.getAnnotations();
 		int length;
 		if (annotations == null || (length = annotations.length) == 0)
-			return ResolvedAnnotation.NoAnnotations;
-		IResolvedAnnotation[] domInstances = new ResolvedAnnotation[length];
+			return AnnotationBinding.NoAnnotations;
+		IAnnotationBinding[] domInstances = new AnnotationBinding[length];
 		for (int i = 0; i < length; i++)
 			domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
 		return domInstances; 
@@ -123,12 +122,12 @@
 		return declaringClass;
 	}
 
-	public IResolvedAnnotation[] getParameterAnnotations(int index) {
-		AnnotationBinding[] annotations = this.binding.getParameterAnnotations(index);
+	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 ResolvedAnnotation.NoAnnotations;
-		IResolvedAnnotation[] domInstances =new ResolvedAnnotation[length];
+			return AnnotationBinding.NoAnnotations;
+		IAnnotationBinding[] domInstances =new AnnotationBinding[length];
 		for (int i = 0; i < length; i++)
 			domInstances[i] = this.resolver.getAnnotationInstance(annotations[i]);
 		return domInstances; 
@@ -166,7 +165,7 @@
 
 	public Object getDefaultValue() {
 		if (isAnnotationMember())
-			return ResolvedMemberValuePair.buildDOMValue(this.binding.getDefaultValue(), this.resolver);
+			return MemberValuePairBinding.buildDOMValue(this.binding.getDefaultValue(), this.resolver);
 		return null;
 	}
 
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageBinding.java
index 9472a37..5b557dd 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/PackageBinding.java
@@ -25,7 +25,6 @@
 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;
@@ -49,18 +48,18 @@
 		this.resolver = resolver;
 	}
 
-	public IResolvedAnnotation[] getAnnotations() {
+	public IAnnotationBinding[] getAnnotations() {
 		try {
 			INameEnvironment nameEnvironment = this.binding.environment.nameEnvironment; 
 			if (!(nameEnvironment instanceof SearchableEnvironment))
-				return ResolvedAnnotation.NoAnnotations;
+				return AnnotationBinding.NoAnnotations;
 			NameLookup nameLookup = ((SearchableEnvironment) nameEnvironment).nameLookup;
 			if (nameLookup == null)
-				return ResolvedAnnotation.NoAnnotations;
+				return AnnotationBinding.NoAnnotations;
 			final String pkgName = getName();
 			IPackageFragment[] pkgs = nameLookup.findPackageFragments(pkgName, false/*exact match*/);
 			if (pkgs == null)
-				return ResolvedAnnotation.NoAnnotations;
+				return AnnotationBinding.NoAnnotations;
 
 			for (int i = 0, len = pkgs.length; i < len; i++) {
 				int fragType = pkgs[i].getKind();
@@ -80,14 +79,14 @@
 							if (pkgDecl != null) {
 								List annos = pkgDecl.annotations();
 								if (annos == null || annos.isEmpty())
-									return ResolvedAnnotation.NoAnnotations; 
-								IResolvedAnnotation[] result = new IResolvedAnnotation[annos.size()];
+									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();
+									result[index] = ((Annotation) it.next()).resolveAnnotationBinding();
 									// not resolving bindings
 									if (result[index] == null)
-										return ResolvedAnnotation.NoAnnotations;							
+										return AnnotationBinding.NoAnnotations;							
 								}
 								return result;
 							}
@@ -99,25 +98,25 @@
 						if (answer != null && answer.isBinaryType()) {
 							IBinaryType type = answer.getBinaryType();
 							IBinaryAnnotation[] binaryAnnotations = type.getAnnotations();
-							AnnotationBinding[] binaryInstances =
+							org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] binaryInstances =
 								BinaryTypeBinding.createAnnotations(binaryAnnotations, this.binding.environment);
-							AnnotationBinding[] allInstances =
-								AnnotationBinding.addStandardAnnotations(binaryInstances, type.getTagBits(), 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;
-							IResolvedAnnotation[] domInstances = new ResolvedAnnotation[total];
+							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 ResolvedAnnotation.NoAnnotations; 
+									return AnnotationBinding.NoAnnotations; 
 							}
 							return domInstances;
 						}
 				}	
 			}		
 		} catch(JavaModelException e) {
-			return ResolvedAnnotation.NoAnnotations;
+			return AnnotationBinding.NoAnnotations;
 		}		
-		return ResolvedAnnotation.NoAnnotations;
+		return AnnotationBinding.NoAnnotations;
 	}
 
 	/*
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java
deleted file mode 100644
index c15bd61..0000000
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedAnnotation.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*******************************************************************************
- * 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();
-	}
-}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java
deleted file mode 100644
index 8b8b20d..0000000
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedDefaultValuePair.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*******************************************************************************
- * 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);
-}
-}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java
deleted file mode 100644
index 6a31261..0000000
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ResolvedMemberValuePair.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*******************************************************************************
- * 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);
-}
-}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
index 0632815..de11418 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/TypeBinding.java
@@ -32,7 +32,6 @@
 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;
@@ -75,15 +74,15 @@
 		this.resolver = resolver;
 	}
 
-	public IResolvedAnnotation[] getAnnotations() { 
-		IResolvedAnnotation[] domInstances = ResolvedAnnotation.NoAnnotations;
+	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;
-			AnnotationBinding[] internalAnnotations = refType.getAnnotations();
+			org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding[] internalAnnotations = refType.getAnnotations();
 			int length = internalAnnotations == null ? 0 : internalAnnotations.length;
 			if (length > 0) {
-				domInstances = new ResolvedAnnotation[length];
+				domInstances = new AnnotationBinding[length];
 				for (int i = 0; i < length; i++)
 					domInstances[i] = this.resolver.getAnnotationInstance(internalAnnotations[i]);
 			}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableBinding.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableBinding.java
index decf1a5..23e74d3 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableBinding.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/VariableBinding.java
@@ -16,7 +16,6 @@
 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;
@@ -43,12 +42,12 @@
 		this.binding = binding;
 	}
 
-	public IResolvedAnnotation[] getAnnotations() { 
-		AnnotationBinding[] internalAnnotations = this.binding.getAnnotations();
+	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;
-		IResolvedAnnotation[] domInstances =
-			length == 0 ? ResolvedAnnotation.NoAnnotations : new ResolvedAnnotation[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;