HEAD - 123470
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;
