[198934] resolve Constant Expressions

30 files changed, 641 insertions, 372 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/IJpaContentNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/IJpaContentNode.java
index 5d83c12bbf..5676d2e104 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/IJpaContentNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/IJpaContentNode.java
@@ -1,8 +1,8 @@
 /*******************************************************************************
  * Copyright (c) 2006, 2007 Oracle. 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.
+ * 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:
  *     Oracle - initial API and implementation
@@ -35,12 +35,6 @@ public interface IJpaContentNode extends IJpaSourceObject
 	Object getId();
 
 	/**
-	 * Return the text range for this contentNode.  This is the all-inclusive
-	 * text range to be used for finding a particular content node given a source location.
-	 */
-	ITextRange fullTextRange();
-
-	/**
 	 * Return the text range to be used for selection. This is the text you want selected
 	 * when selecting the object in the editor. StructureView uses this for selection
 	 * from the structure to the source editor.
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/JpaCompilationUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/JpaCompilationUnit.java
index a65a6d39e8..f7e19648dc 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/JpaCompilationUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/JpaCompilationUnit.java
@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+
 import org.eclipse.core.resources.IFile;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.EList;
@@ -34,7 +35,6 @@ import org.eclipse.jpt.core.internal.IJpaRootContentNode;
 import org.eclipse.jpt.core.internal.ITextRange;
 import org.eclipse.jpt.core.internal.JpaCorePackage;
 import org.eclipse.jpt.core.internal.JpaFile;
-import org.eclipse.jpt.core.internal.jdtutility.ASTNodeTextRange;
 import org.eclipse.jpt.core.internal.jdtutility.AttributeAnnotationTools;
 import org.eclipse.jpt.core.internal.jdtutility.JDTTools;
 import org.eclipse.jpt.utility.internal.BitTools;
@@ -289,10 +289,6 @@ public class JpaCompilationUnit extends JavaEObject
 		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
 	}
 
-	public ITextRange fullTextRange() {
-		return new ASTNodeTextRange(this.astRoot());
-	}
-
 	public ITextRange validationTextRange() {
 		return this.selectionTextRange();
 	}
@@ -446,8 +442,8 @@ public class JpaCompilationUnit extends JavaEObject
 		return EmptyIterator.instance();
 	}
 
-	public CompilationUnit astRoot() {
-		return JDTTools.createASTRoot(this.compilationUnit);
+	private CompilationUnit astRoot() {
+		return JDTTools.buildASTRoot(this.compilationUnit);
 	}
 
 	public void dispose() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaBasic.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaBasic.java
index d939946ed4..2bb982f3a7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaBasic.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaBasic.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.internal.content.java.mappings;
 
 import java.util.Iterator;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
@@ -21,7 +22,6 @@ import org.eclipse.jdt.core.ITypeHierarchy;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.WorkingCopyOwner;
-import org.eclipse.jdt.core.dom.BooleanLiteral;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.internal.IMappingKeys;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationAdapter;
@@ -752,7 +752,7 @@ public class JavaBasic extends JavaAttributeMapping implements IJavaBasic
 
 	// ********** static methods **********
 	private static DeclarationAnnotationElementAdapter<String> buildOptionalAdapter() {
-		return new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(DECLARATION_ANNOTATION_ADAPTER, JPA.BASIC__OPTIONAL, false, BooleanStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(DECLARATION_ANNOTATION_ADAPTER, JPA.BASIC__OPTIONAL, false, BooleanStringExpressionConverter.instance());
 	}
 
 	private static DeclarationAnnotationElementAdapter<String> buildFetchAdapter() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaEntity.java
index be1dcd9677..af5eee8943 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaEntity.java
@@ -12,6 +12,7 @@ package org.eclipse.jpt.core.internal.content.java.mappings;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.EList;
@@ -23,7 +24,6 @@ import org.eclipse.emf.ecore.util.EObjectEList;
 import org.eclipse.emf.ecore.util.InternalEList;
 import org.eclipse.jdt.core.dom.Annotation;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.TypeLiteral;
 import org.eclipse.jpt.core.internal.IMappingKeys;
 import org.eclipse.jpt.core.internal.IPersistentAttribute;
 import org.eclipse.jpt.core.internal.IPersistentType;
@@ -3006,6 +3006,6 @@ public class JavaEntity extends JavaTypeMapping implements IJavaEntity
 
 	// ********** static methods **********
 	private static DeclarationAnnotationElementAdapter<String> buildIdClassValueAdapter() {
-		return new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(ID_CLASS_ADAPTER, JPA.ID_CLASS__VALUE, false, SimpleTypeStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(ID_CLASS_ADAPTER, JPA.ID_CLASS__VALUE, false, SimpleTypeStringExpressionConverter.instance());
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaGenerator.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaGenerator.java
index 8066e5356c..25c53ac257 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaGenerator.java
@@ -13,7 +13,6 @@ import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jpt.core.internal.ITextRange;
 import org.eclipse.jpt.core.internal.content.java.JavaEObject;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
@@ -565,6 +564,6 @@ public abstract class JavaGenerator extends JavaEObject implements IGenerator
 	}
 
 	protected static DeclarationAnnotationElementAdapter<String> buildNumberAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, NumberLiteral>(annotationAdapter, elementName, NumberStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, NumberStringExpressionConverter.instance());
 	}
 } // JavaGenerator
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaMappedSuperclass.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaMappedSuperclass.java
index 90a53833da..0b904311e0 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaMappedSuperclass.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaMappedSuperclass.java
@@ -10,11 +10,11 @@
 package org.eclipse.jpt.core.internal.content.java.mappings;
 
 import java.util.Iterator;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.TypeLiteral;
 import org.eclipse.jpt.core.internal.IMappingKeys;
 import org.eclipse.jpt.core.internal.IPersistentAttribute;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationAdapter;
@@ -337,6 +337,6 @@ public class JavaMappedSuperclass extends JavaTypeMapping
 
 	// ********** static methods **********
 	private static DeclarationAnnotationElementAdapter<String> buildIdClassValueAdapter() {
-		return new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(ID_CLASS_ADAPTER, JPA.ID_CLASS__VALUE, false, SimpleTypeStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(ID_CLASS_ADAPTER, JPA.ID_CLASS__VALUE, false, SimpleTypeStringExpressionConverter.instance());
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaNamedColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaNamedColumn.java
index 61b7da6e2d..abfb4c3c9d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaNamedColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaNamedColumn.java
@@ -10,12 +10,11 @@
 package org.eclipse.jpt.core.internal.content.java.mappings;
 
 import java.util.Iterator;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.jdt.core.dom.BooleanLiteral;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jpt.core.internal.ITextRange;
 import org.eclipse.jpt.core.internal.content.java.JavaEObject;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
@@ -152,11 +151,11 @@ public abstract class JavaNamedColumn extends JavaEObject
 	}
 
 	protected DeclarationAnnotationElementAdapter<String> buildBooleanElementAdapter(String elementName) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(this.daa, elementName, BooleanStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(this.daa, elementName, BooleanStringExpressionConverter.instance());
 	}
 
 	protected DeclarationAnnotationElementAdapter<String> buildIntElementAdapter(String elementName) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, NumberLiteral>(this.daa, elementName, NumberStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(this.daa, elementName, NumberStringExpressionConverter.instance());
 	}
 
 	protected AnnotationElementAdapter<String> buildShortCircuitElementAdapter(DeclarationAnnotationElementAdapter<String> daea) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaRelationshipMapping.java
index 9deacff895..1b16973e04 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaRelationshipMapping.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.internal.content.java.mappings;
 
 import java.util.Iterator;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
@@ -18,7 +19,6 @@ import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jpt.core.internal.IPersistentType;
 import org.eclipse.jpt.core.internal.ITypeMapping;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
@@ -562,7 +562,7 @@ public abstract class JavaRelationshipMapping extends JavaAttributeMapping
 		if (this.cascade != null) {
 			((JavaCascade) this.cascade).updateFromJava(astRoot);
 		}
-		else if (cascadeAdapter().expression(getAttribute().modifiedDeclaration()) != null) {
+		else if (cascadeAdapter().expression(getAttribute().modifiedDeclaration(astRoot)) != null) {
 			setCascade(createCascade());
 			((JavaCascade) this.cascade).updateFromJava(astRoot);
 		}
@@ -654,8 +654,8 @@ public abstract class JavaRelationshipMapping extends JavaAttributeMapping
 		return buildAnnotationElementAdapter(annotationAdapter, elementName, StringExpressionConverter.instance());
 	}
 
-	protected static <T extends Expression> DeclarationAnnotationElementAdapter<String> buildAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<String, T> converter) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, T>(annotationAdapter, elementName, false, converter);
+	protected static DeclarationAnnotationElementAdapter<String> buildAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<String> converter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, false, converter);
 	}
 
 	protected static DeclarationAnnotationElementAdapter<String> buildEnumAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaSingleRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaSingleRelationshipMapping.java
index 3639e7d416..aa0415bfd3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaSingleRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaSingleRelationshipMapping.java
@@ -1,8 +1,8 @@
 /*******************************************************************************
  * Copyright (c) 2006, 2007 Oracle. 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.
+ * 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:
  *     Oracle - initial API and implementation
@@ -12,6 +12,7 @@ package org.eclipse.jpt.core.internal.content.java.mappings;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.util.EList;
@@ -20,7 +21,6 @@ import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jdt.core.dom.BooleanLiteral;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
 import org.eclipse.jpt.core.internal.jdtutility.Attribute;
@@ -681,6 +681,6 @@ public abstract class JavaSingleRelationshipMapping
 
 	// ********** static methods **********
 	protected static DeclarationAnnotationElementAdapter<String> buildOptionalAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(annotationAdapter, elementName, false, BooleanStringExpressionConverter.instance());
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, false, BooleanStringExpressionConverter.instance());
 	}
 } // JavaSingleRelationshipMapping
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaUniqueConstraint.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaUniqueConstraint.java
index 84055b9f69..01706c49fc 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaUniqueConstraint.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/content/java/mappings/JavaUniqueConstraint.java
@@ -11,13 +11,13 @@ package org.eclipse.jpt.core.internal.content.java.mappings;
 
 import java.util.Collection;
 import java.util.Iterator;
+
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.util.EDataTypeEList;
 import org.eclipse.jdt.core.dom.Annotation;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jpt.core.internal.ITextRange;
 import org.eclipse.jpt.core.internal.content.java.JavaEObject;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
@@ -97,11 +97,11 @@ public class JavaUniqueConstraint extends JavaEObject
 	}
 
 	protected static DeclarationAnnotationElementAdapter<String[]> buildArrayAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
-		return buildArrayAnnotationElementAdapter(annotationAdapter, elementName, AnnotationStringArrayExpressionConverter.forStringLiterals());
+		return buildArrayAnnotationElementAdapter(annotationAdapter, elementName, AnnotationStringArrayExpressionConverter.forStrings());
 	}
 
-	protected static DeclarationAnnotationElementAdapter<String[]> buildArrayAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<String[], Expression> converter) {
-		return new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(annotationAdapter, elementName, false, converter);
+	protected static DeclarationAnnotationElementAdapter<String[]> buildArrayAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<String[]> converter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String[]>(annotationAdapter, elementName, false, converter);
 	}
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AbstractExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AbstractExpressionConverter.java
index cd87259db9..11f4ad34ca 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AbstractExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AbstractExpressionConverter.java
@@ -14,26 +14,35 @@ import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jpt.utility.internal.StringTools;
 
 /**
- * Gather together just the tiniest bit of common behavior.
- * E is the expression type.
+ * Gather together the common implementation behavior.
  * T is the type of the object to be converted to and from an expression.
+ * 
+ * We're still figuring out Java Generics here.... The methods in this abstract
+ * class work fine with any subclass of Expression E; but a ClassCastException
+ * will occur as soon as we call any method implemented by a subclass
+ * (e.g. StringExpressionConverter) that expects a particular subclass of
+ * Expression (e.g. StringLiteral).
  */
-public abstract class AbstractExpressionConverter<T, E extends Expression>
-	implements ExpressionConverter<T, E>
+public abstract class AbstractExpressionConverter<T>
+	implements ExpressionConverter<T>
 {
 
 	protected AbstractExpressionConverter() {
 		super();
 	}
 
-	public E convert(T object, AST ast) {
-		return (object == null) ? this.convertNull(ast) : this.convert_(object, ast);
+
+	// ********** object -> expression **********
+
+	public Expression convert(T object, AST ast) {
+		return (object == null) ? this.convertNull(ast) : this.convertObject(object, ast);
 	}
 
 	/**
-	 * Return the expression for a null object.
+	 * Return the expression for a null object. By default, a null object will
+	 * be converted into a null expression.
 	 */
-	protected E convertNull(AST ast) {
+	protected Expression convertNull(AST ast) {
 		return null;
 	}
 
@@ -41,14 +50,18 @@ public abstract class AbstractExpressionConverter<T, E extends Expression>
 	 * The specified object is not null.
 	 * @see #convert(T, AST)
 	 */
-	protected abstract E convert_(T object, AST ast);
+	protected abstract Expression convertObject(T object, AST ast);
+
+
+	// ********** expression -> object **********
 
-	public T convert(E expression) {
-		return (expression == null) ? this.convertNull() : this.convert_(expression);
+	public T convert(Expression expression) {
+		return (expression == null) ? this.convertNull() : this.convertExpression(expression);
 	}
 
 	/**
-	 * Return the object for a null expression.
+	 * Return the object for a null expression. By default, a null expression will
+	 * be converted into a null object.
 	 */
 	protected T convertNull() {
 		return null;
@@ -58,7 +71,7 @@ public abstract class AbstractExpressionConverter<T, E extends Expression>
 	 * The specified expression is not null.
 	 * @see #convert(Expression)
 	 */
-	protected abstract T convert_(E expression);
+	protected abstract T convertExpression(Expression expression);
 
 	@Override
 	public String toString() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AnnotationStringArrayExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AnnotationStringArrayExpressionConverter.java
index ad49351540..21557f6944 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AnnotationStringArrayExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/AnnotationStringArrayExpressionConverter.java
@@ -13,8 +13,6 @@ import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ArrayInitializer;
 import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.Name;
-import org.eclipse.jdt.core.dom.StringLiteral;
 
 /**
  * Convert an array initializer or single expression to/from an array of
@@ -22,24 +20,24 @@ import org.eclipse.jdt.core.dom.StringLiteral;
  * E is the type of the expressions to be found either standalone or
  * as elements in the array initializer.
  */
-public class AnnotationStringArrayExpressionConverter<E extends Expression>
-	extends AbstractExpressionConverter<String[], Expression>
+public class AnnotationStringArrayExpressionConverter
+	extends AbstractExpressionConverter<String[]>
 {
-	private final ExpressionConverter<String, E> elementConverter;
-	private final StringArrayExpressionConverter<E> arrayConverter;
+	private final ExpressionConverter<String> elementConverter;
+	private final StringArrayExpressionConverter arrayConverter;
 
 
 	/**
 	 * The default behavior is to remove the array initializer if it is empty.
 	 */
-	public AnnotationStringArrayExpressionConverter(ExpressionConverter<String, E> elementConverter) {
+	public AnnotationStringArrayExpressionConverter(ExpressionConverter<String> elementConverter) {
 		this(elementConverter, true);
 	}
 
-	public AnnotationStringArrayExpressionConverter(ExpressionConverter<String, E> elementConverter, boolean removeArrayInitializerWhenEmpty) {
+	public AnnotationStringArrayExpressionConverter(ExpressionConverter<String> elementConverter, boolean removeArrayInitializerWhenEmpty) {
 		super();
 		this.elementConverter = elementConverter;
-		this.arrayConverter = new StringArrayExpressionConverter<E>(elementConverter, removeArrayInitializerWhenEmpty);
+		this.arrayConverter = new StringArrayExpressionConverter(elementConverter, removeArrayInitializerWhenEmpty);
 	}
 
 	/**
@@ -47,11 +45,11 @@ public class AnnotationStringArrayExpressionConverter<E extends Expression>
 	 * without braces, instead of an array initializer
 	 */
 	@Override
-	protected Expression convert_(String[] strings, AST ast) {
+	protected Expression convertObject(String[] strings, AST ast) {
 		return (strings.length == 1) ?
 				this.elementConverter.convert(strings[0], ast)
 			:
-				this.arrayConverter.convert_(strings, ast);
+				this.arrayConverter.convertObject(strings, ast);
 	}
 
 	@Override
@@ -64,16 +62,11 @@ public class AnnotationStringArrayExpressionConverter<E extends Expression>
 	 * single-entry array
 	 */
 	@Override
-	protected String[] convert_(Expression expression) {
+	protected String[] convertExpression(Expression expression) {
 		return (expression.getNodeType() == ASTNode.ARRAY_INITIALIZER) ?
-				this.arrayConverter.convert_((ArrayInitializer) expression)
+				this.arrayConverter.convertArrayInitializer((ArrayInitializer) expression)
 			:
-				new String[] {this.elementConverter.convert(this.downcastExpression(expression))};
-	}
-
-	@SuppressWarnings("unchecked")
-	private E downcastExpression(Expression expression) {
-		return (E) expression;
+				new String[] {this.elementConverter.convert(expression)};
 	}
 
 
@@ -85,8 +78,8 @@ public class AnnotationStringArrayExpressionConverter<E extends Expression>
 	 * or
 	 *     @Foo(bar="text0")
 	 */
-	public static AnnotationStringArrayExpressionConverter<StringLiteral> forStringLiterals() {
-		return new AnnotationStringArrayExpressionConverter<StringLiteral>(StringExpressionConverter.instance());
+	public static AnnotationStringArrayExpressionConverter forStrings() {
+		return new AnnotationStringArrayExpressionConverter(StringExpressionConverter.instance());
 	}
 
 	/**
@@ -95,8 +88,8 @@ public class AnnotationStringArrayExpressionConverter<E extends Expression>
 	 * or
 	 *     @Foo(bar=BAZ)
 	 */
-	public static AnnotationStringArrayExpressionConverter<Name> forNames() {
-		return new AnnotationStringArrayExpressionConverter<Name>(NameStringExpressionConverter.instance());
+	public static AnnotationStringArrayExpressionConverter forNames() {
+		return new AnnotationStringArrayExpressionConverter(NameStringExpressionConverter.instance());
 	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/BooleanStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/BooleanStringExpressionConverter.java
index 0f5854e5d6..f7bf5d6063 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/BooleanStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/BooleanStringExpressionConverter.java
@@ -10,22 +10,22 @@
 package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
-import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.BooleanLiteral;
+import org.eclipse.jdt.core.dom.Expression;
 
 /**
  * Convert a boolean literal to/from a string representation of a boolean
  * (e.g. "true").
  */
 public final class BooleanStringExpressionConverter
-	extends AbstractExpressionConverter<String, BooleanLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, BooleanLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, BooleanLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new BooleanStringExpressionConverter();
 		}
@@ -40,16 +40,14 @@ public final class BooleanStringExpressionConverter
 	}
 
 	@Override
-	protected BooleanLiteral convert_(String string, AST ast) {
+	protected BooleanLiteral convertObject(String string, AST ast) {
 		return ast.newBooleanLiteral(Boolean.valueOf(string).booleanValue());
 	}
 
 	@Override
-	protected String convert_(BooleanLiteral booleanLiteral) {
-		return (booleanLiteral.getNodeType() == ASTNode.BOOLEAN_LITERAL) ?
-			Boolean.toString(booleanLiteral.booleanValue())
-		:
-			null;
+	protected String convertExpression(Expression expression) {
+		Object value = expression.resolveConstantExpressionValue();
+		return (value instanceof Boolean) ? ((Boolean) value).toString() : null;
 	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/CharacterStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/CharacterStringExpressionConverter.java
index 1fa055d707..dfc2fdcc71 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/CharacterStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/CharacterStringExpressionConverter.java
@@ -10,22 +10,22 @@
 package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
-import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.CharacterLiteral;
+import org.eclipse.jdt.core.dom.Expression;
 
 /**
  * Convert a character literal to/from a string representation of a character
  * (e.g. "A").
  */
 public final class CharacterStringExpressionConverter
-	extends AbstractExpressionConverter<String, CharacterLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, CharacterLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, CharacterLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new CharacterStringExpressionConverter();
 		}
@@ -40,18 +40,16 @@ public final class CharacterStringExpressionConverter
 	}
 	
 	@Override
-	protected CharacterLiteral convert_(String string, AST ast) {
+	protected CharacterLiteral convertObject(String string, AST ast) {
 		CharacterLiteral characterLiteral = ast.newCharacterLiteral();
 		characterLiteral.setCharValue(string.charAt(0));
 		return characterLiteral;
 	}
 
 	@Override
-	protected String convert_(CharacterLiteral characterLiteral) {
-		return (characterLiteral.getNodeType() == ASTNode.CHARACTER_LITERAL) ?
-			Character.toString(characterLiteral.charValue())
-		:
-			null;
+	protected String convertExpression(Expression expression) {
+		Object value = expression.resolveConstantExpressionValue();
+		return (value instanceof Character) ? ((Character) value).toString() : null;
 	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ConversionDeclarationAnnotationElementAdapter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ConversionDeclarationAnnotationElementAdapter.java
index 088fa0cad4..f6cf01060f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ConversionDeclarationAnnotationElementAdapter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ConversionDeclarationAnnotationElementAdapter.java
@@ -11,78 +11,51 @@ package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.StringLiteral;
 import org.eclipse.jpt.utility.internal.StringTools;
 
 /**
  * Wrap a declaration annotation element adapter that deals with AST
  * expressions, converting them to/from various other objects.
  * T is the type of the object to be passed to and returned by the adapter.
- * E is the type of the expression to be converted by the converter.
  */
-public class ConversionDeclarationAnnotationElementAdapter<T, E extends Expression>
+public class ConversionDeclarationAnnotationElementAdapter<T>
 	implements DeclarationAnnotationElementAdapter<T>
 {
 	/**
 	 * The wrapped adapter that returns and takes AST expressions.
 	 */
-	private final DeclarationAnnotationElementAdapter<E> adapter;
+	private final DeclarationAnnotationElementAdapter<Expression> adapter;
 
 	/**
 	 * The converter that converts AST expressions to other objects
 	 * (e.g. Strings).
 	 */
-	private final ExpressionConverter<T, E> converter;
+	private final ExpressionConverter<T> converter;
 
 
 	// ********** constructors **********
 
 	/**
 	 * The default element name is "value"; the default behavior is to
-	 * remove the annotation when the last element is removed;
-	 * the default expression converter expects string literals.
-	 */
-	public static ConversionDeclarationAnnotationElementAdapter<String, StringLiteral> forStrings(DeclarationAnnotationAdapter annotationAdapter) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, StringLiteral>(annotationAdapter, StringExpressionConverter.instance());
-	}
-
-	/**
-	 * The default element name is "value"; the default behavior is to
 	 * remove the annotation when the last element is removed.
 	 */
-	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, ExpressionConverter<T, E> converter) {
-		this(new ExpressionDeclarationAnnotationElementAdapter<E>(annotationAdapter), converter);
-	}
-
-	/**
-	 * The default behavior is to remove the annotation when the last
-	 * element is removed; the default expression converter expects
-	 * string literals.
-	 */
-	public static ConversionDeclarationAnnotationElementAdapter<String, StringLiteral> forStrings(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, StringLiteral>(annotationAdapter, elementName, StringExpressionConverter.instance());
+	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, ExpressionConverter<T> converter) {
+		this(new ExpressionDeclarationAnnotationElementAdapter<Expression>(annotationAdapter), converter);
 	}
 
 	/**
 	 * The default behavior is to remove the annotation when the last
 	 * element is removed.
 	 */
-	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<T, E> converter) {
-		this(new ExpressionDeclarationAnnotationElementAdapter<E>(annotationAdapter, elementName), converter);
-	}
-
-	/**
-	 * The default expression converter expects string literals.
-	 */
-	public static ConversionDeclarationAnnotationElementAdapter<String, StringLiteral> forStrings(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
-		return new ConversionDeclarationAnnotationElementAdapter<String, StringLiteral>(annotationAdapter, elementName, removeAnnotationWhenEmpty, StringExpressionConverter.instance());
+	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, ExpressionConverter<T> converter) {
+		this(new ExpressionDeclarationAnnotationElementAdapter<Expression>(annotationAdapter, elementName), converter);
 	}
 
-	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty, ExpressionConverter<T, E> converter) {
-		this(new ExpressionDeclarationAnnotationElementAdapter<E>(annotationAdapter, elementName, removeAnnotationWhenEmpty), converter);
+	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty, ExpressionConverter<T> converter) {
+		this(new ExpressionDeclarationAnnotationElementAdapter<Expression>(annotationAdapter, elementName, removeAnnotationWhenEmpty), converter);
 	}
 
-	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationElementAdapter<E> adapter, ExpressionConverter<T, E> converter) {
+	public ConversionDeclarationAnnotationElementAdapter(DeclarationAnnotationElementAdapter<Expression> adapter, ExpressionConverter<T> converter) {
 		super();
 		this.adapter = adapter;
 		this.converter = converter;
@@ -112,4 +85,107 @@ public class ConversionDeclarationAnnotationElementAdapter<T, E extends Expressi
 		return StringTools.buildToStringFor(this, this.adapter);
 	}
 
+
+	// ********** factory static methods **********
+
+	/**
+	 * The default element name is "value"; the default behavior is to
+	 * remove the annotation when the last element is removed;
+	 * the default expression converter expects string constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forStrings(DeclarationAnnotationAdapter annotationAdapter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, StringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default behavior is to remove the annotation when the last
+	 * element is removed; the default expression converter expects
+	 * string constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forStrings(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, StringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default expression converter expects string constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forStrings(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, removeAnnotationWhenEmpty, StringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default element name is "value"; the default behavior is to
+	 * remove the annotation when the last element is removed;
+	 * the default expression converter expects number constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forNumbers(DeclarationAnnotationAdapter annotationAdapter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, NumberStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default behavior is to remove the annotation when the last
+	 * element is removed; the default expression converter expects
+	 * number constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forNumbers(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, NumberStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default expression converter expects number constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forNumbers(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, removeAnnotationWhenEmpty, NumberStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default element name is "value"; the default behavior is to
+	 * remove the annotation when the last element is removed;
+	 * the default expression converter expects boolean constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forBooleans(DeclarationAnnotationAdapter annotationAdapter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, BooleanStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default behavior is to remove the annotation when the last
+	 * element is removed; the default expression converter expects
+	 * boolean constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forBooleans(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, BooleanStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default expression converter expects boolean constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forBooleans(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, removeAnnotationWhenEmpty, BooleanStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default element name is "value"; the default behavior is to
+	 * remove the annotation when the last element is removed;
+	 * the default expression converter expects character constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forCharacters(DeclarationAnnotationAdapter annotationAdapter) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, CharacterStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default behavior is to remove the annotation when the last
+	 * element is removed; the default expression converter expects
+	 * character constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forCharacters(DeclarationAnnotationAdapter annotationAdapter, String elementName) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, CharacterStringExpressionConverter.instance());
+	}
+
+	/**
+	 * The default expression converter expects character constant expressions.
+	 */
+	public static ConversionDeclarationAnnotationElementAdapter<String> forCharacters(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
+		return new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, removeAnnotationWhenEmpty, CharacterStringExpressionConverter.instance());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumArrayDeclarationAnnotationElementAdapter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumArrayDeclarationAnnotationElementAdapter.java
index de08d4ac8e..633088588a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumArrayDeclarationAnnotationElementAdapter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumArrayDeclarationAnnotationElementAdapter.java
@@ -14,7 +14,6 @@ import java.util.List;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ArrayInitializer;
 import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.Name;
 
 /**
  * Wrap a declaration annotation element adapter and simply
@@ -26,7 +25,7 @@ public class EnumArrayDeclarationAnnotationElementAdapter
 	/**
 	 * The wrapped adapter that returns and takes name strings (enums).
 	 */
-	private final ConversionDeclarationAnnotationElementAdapter<String[], Expression> adapter;
+	private final ConversionDeclarationAnnotationElementAdapter<String[]> adapter;
 
 	private static final String[] EMPTY_STRING_ARRAY = new String[0];
 
@@ -57,14 +56,14 @@ public class EnumArrayDeclarationAnnotationElementAdapter
 	}
 
 	public EnumArrayDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty, boolean removeArrayInitializerWhenEmpty) {
-		this(new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(annotationAdapter, elementName, removeAnnotationWhenEmpty, buildExpressionConverter(removeArrayInitializerWhenEmpty)));
+		this(new ConversionDeclarationAnnotationElementAdapter<String[]>(annotationAdapter, elementName, removeAnnotationWhenEmpty, buildExpressionConverter(removeArrayInitializerWhenEmpty)));
 	}
 
-	private static ExpressionConverter<String[], Expression> buildExpressionConverter(boolean removeArrayInitializerWhenEmpty) {
-		return new AnnotationStringArrayExpressionConverter<Name>(NameStringExpressionConverter.instance(), removeArrayInitializerWhenEmpty);
+	private static ExpressionConverter<String[]> buildExpressionConverter(boolean removeArrayInitializerWhenEmpty) {
+		return new AnnotationStringArrayExpressionConverter(NameStringExpressionConverter.instance(), removeArrayInitializerWhenEmpty);
 	}
 
-	protected EnumArrayDeclarationAnnotationElementAdapter(ConversionDeclarationAnnotationElementAdapter<String[], Expression> adapter) {
+	protected EnumArrayDeclarationAnnotationElementAdapter(ConversionDeclarationAnnotationElementAdapter<String[]> adapter) {
 		super();
 		this.adapter = adapter;
 	}
@@ -100,13 +99,13 @@ public class EnumArrayDeclarationAnnotationElementAdapter
 	 * or
 	 *     FOO
 	 */
-	protected String[] resolve(Expression enumsExpression, ModifiedDeclaration declaration) {
-		if (enumsExpression == null) {
+	protected String[] resolve(Expression expression, ModifiedDeclaration declaration) {
+		if (expression == null) {
 			return EMPTY_STRING_ARRAY;
-		} else if (enumsExpression.getNodeType() == ASTNode.ARRAY_INITIALIZER) {
-			return this.resolveArray((ArrayInitializer) enumsExpression, declaration);
+		} else if (expression.getNodeType() == ASTNode.ARRAY_INITIALIZER) {
+			return this.resolveArray((ArrayInitializer) expression, declaration);
 		} else {
-			return this.resolveSingleElement(enumsExpression, declaration);
+			return this.resolveSingleElement(expression, declaration);
 		}
 	}
 
@@ -115,17 +114,17 @@ public class EnumArrayDeclarationAnnotationElementAdapter
 		int len = expressions.size();
 		String[] enums = new String[len];
 		for (int i = len; i-- > 0; ) {
-			enums[i] = this.resolveEnum(expressions.get(i), declaration);
+			enums[i] = this.resolveEnum(expressions.get(i));
 		}
 		return enums;
 	}
 
 	protected String[] resolveSingleElement(Expression enumExpression, ModifiedDeclaration declaration) {
-		return new String[] {this.resolveEnum(enumExpression, declaration)};
+		return new String[] {this.resolveEnum(enumExpression)};
 	}
 
-	protected String resolveEnum(Expression enumExpression, ModifiedDeclaration declaration) {
-		return JDTTools.resolveEnum(declaration.iCompilationUnit(), enumExpression);
+	protected String resolveEnum(Expression expression) {
+		return JDTTools.resolveEnum(expression);
 	}
 
 	@SuppressWarnings("unchecked")
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumDeclarationAnnotationElementAdapter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumDeclarationAnnotationElementAdapter.java
index 838860f486..2f0c1f704b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumDeclarationAnnotationElementAdapter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/EnumDeclarationAnnotationElementAdapter.java
@@ -23,7 +23,7 @@ public class EnumDeclarationAnnotationElementAdapter
 	/**
 	 * The wrapped adapter that returns and takes name strings (enums).
 	 */
-	private final ConversionDeclarationAnnotationElementAdapter<String, Name> adapter;
+	private final ConversionDeclarationAnnotationElementAdapter<String> adapter;
 
 
 	// ********** constructors **********
@@ -45,10 +45,10 @@ public class EnumDeclarationAnnotationElementAdapter
 	}
 
 	public EnumDeclarationAnnotationElementAdapter(DeclarationAnnotationAdapter annotationAdapter, String elementName, boolean removeAnnotationWhenEmpty) {
-		this(new ConversionDeclarationAnnotationElementAdapter<String, Name>(annotationAdapter, elementName, removeAnnotationWhenEmpty, NameStringExpressionConverter.instance()));
+		this(new ConversionDeclarationAnnotationElementAdapter<String>(annotationAdapter, elementName, removeAnnotationWhenEmpty, NameStringExpressionConverter.instance()));
 	}
 
-	protected EnumDeclarationAnnotationElementAdapter(ConversionDeclarationAnnotationElementAdapter<String, Name> adapter) {
+	protected EnumDeclarationAnnotationElementAdapter(ConversionDeclarationAnnotationElementAdapter<String> adapter) {
 		super();
 		this.adapter = adapter;
 	}
@@ -57,7 +57,7 @@ public class EnumDeclarationAnnotationElementAdapter
 	// ********** DeclarationAnnotationElementAdapter implementation **********
 
 	public String getValue(ModifiedDeclaration declaration) {
-		return this.resolve(this.adapter.expression(declaration), declaration);
+		return this.resolve(this.adapter.expression(declaration));
 	}
 
 	public void setValue(String value, ModifiedDeclaration declaration) {
@@ -78,8 +78,8 @@ public class EnumDeclarationAnnotationElementAdapter
 	/**
 	 * resolve the enum
 	 */
-	protected String resolve(Expression enumExpression, ModifiedDeclaration declaration) {
-		return (enumExpression == null) ? null : JDTTools.resolveEnum(declaration.iCompilationUnit(), enumExpression);
+	protected String resolve(Expression expression) {
+		return JDTTools.resolveEnum(expression);
 	}
 
 	/**
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ExpressionConverter.java
index 4bce4344d9..fce8284cfa 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ExpressionConverter.java
@@ -15,10 +15,9 @@ import org.eclipse.jdt.core.dom.Expression;
 /**
  * Define the protocol for converting an AST expression back and forth
  * from an arbitrary type (e.g. StringLiteral <=> String).
- * E is the expression type.
  * T is the type of the object to be converted to and from an expression.
  */
-public interface ExpressionConverter<T, E extends Expression> {
+public interface ExpressionConverter<T> {
 
 	/**
 	 * Convert the specified object to an
@@ -26,12 +25,12 @@ public interface ExpressionConverter<T, E extends Expression> {
 	 * The type of the object is determined by the
 	 * contract specified by the client.
 	 */
-	E convert(T object, AST ast);
+	Expression convert(T object, AST ast);
 
 	/**
 	 * Convert the specified expression to an object of some
 	 * pre-determined type.
 	 */
-	T convert(E expression);
+	T convert(Expression expression);
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/JDTTools.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/JDTTools.java
index 3491df0858..5c513e62a3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/JDTTools.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/JDTTools.java
@@ -9,84 +9,85 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jdtutility;
 
-import org.eclipse.jdt.core.Flags;
 import org.eclipse.jdt.core.IClassFile;
 import org.eclipse.jdt.core.ICompilationUnit;
-import org.eclipse.jdt.core.IImportDeclaration;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IMember;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
-import org.eclipse.jdt.core.compiler.CategorizedProblem;
 import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTParser;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.internal.codeassist.ISelectionRequestor;
-import org.eclipse.jdt.internal.codeassist.SelectionEngine;
-import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
-import org.eclipse.jdt.internal.core.JavaProject;
-import org.eclipse.jdt.internal.core.SearchableEnvironment;
+import org.eclipse.jdt.core.dom.IBinding;
+import org.eclipse.jdt.core.dom.IVariableBinding;
+import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jpt.core.internal.JptCorePlugin;
 
 public class JDTTools {
 
+	// TODO get rid of the "lightweight" methods after reworking how
+	// ValidationMessages determine line numbers
 	/**
-	 * add a "normal" import, as opposed to a "static" import
+	 * Build an AST for the specified member's compilation unit or
+	 * (source-attached) class file. Build the AST without its bindings
+	 * resolved.
 	 */
-	public static IImportDeclaration addImport(ICompilationUnit compilationUnit, String importElement) {
-		return addImport(compilationUnit, importElement, Flags.AccDefault);
+	public static CompilationUnit buildLightweightASTRoot(IMember member) {
+		return buildASTRoot(member, false);
 	}
 
 	/**
-	 * this doesn't work yet... see eclipse bugzilla 143684
+	 * Build an AST for the specified member's compilation unit or
+	 * (source-attached) class file. Build the AST with its bindings
+	 * resolved (and the resultant performance hit).
 	 */
-	public static IImportDeclaration addStaticImport(ICompilationUnit compilationUnit, String importElement) {
-		return addImport(compilationUnit, importElement, Flags.AccStatic);
-	}
-
-	public static IImportDeclaration addImport(ICompilationUnit compilationUnit, String importElement, int flags) {
-		try {
-			return compilationUnit.createImport(importElement, null, flags, null);  // null = place at end of import list; null = no progress monitor
-		} catch (JavaModelException ex) {
-			throw new RuntimeException(ex);
-		}
+	public static CompilationUnit buildASTRoot(IMember member) {
+		return buildASTRoot(member, true);
 	}
 
 	/**
-	 * Build an AST for the specified member's compilation unit or class file.
+	 * Build an AST for the specified member's compilation unit or
+	 * (source-attached) class file.
 	 */
-	public static CompilationUnit createASTRoot(IMember member) {
+	private static CompilationUnit buildASTRoot(IMember member, boolean resolveBindings) {
 		return (member.isBinary()) ?
-			createASTRoot(member.getClassFile())  // the class file must have a source attachment
+			buildASTRoot(member.getClassFile(), resolveBindings)  // the class file must have a source attachment
 		:
-			createASTRoot(member.getCompilationUnit());
+			buildASTRoot(member.getCompilationUnit(), resolveBindings);
 	}
 	
-	public static CompilationUnit createASTRoot(IClassFile classFile) {
+	public static CompilationUnit buildASTRoot(IClassFile classFile) {
+		return buildASTRoot(classFile, true);
+	}
+	
+	private static CompilationUnit buildASTRoot(IClassFile classFile, boolean resolveBindings) {
 		ASTParser parser = ASTParser.newParser(AST.JLS3);
 		parser.setSource(classFile);
+		parser.setResolveBindings(resolveBindings);
 		return (CompilationUnit) parser.createAST(null);
-		
 	}
 	
-	public static CompilationUnit createASTRoot(ICompilationUnit compilationUnit) {
+	public static CompilationUnit buildASTRoot(ICompilationUnit compilationUnit) {
+		return buildASTRoot(compilationUnit, true);
+	}
+	
+	private static CompilationUnit buildASTRoot(ICompilationUnit compilationUnit, boolean resolveBindings) {
 		ASTParser parser = ASTParser.newParser(AST.JLS3);
 		parser.setSource(compilationUnit);
+		parser.setResolveBindings(resolveBindings);
 		return (CompilationUnit) parser.createAST(null);
 	}
 	
 	public static IType findType(String packageName, String qualifiedTypeName, IJavaProject javaProject) {
 		try {
-			if (javaProject != null) {
-				return javaProject.findType(packageName, qualifiedTypeName.replace('$', '.'));
-			}
-		} 
-		catch (JavaModelException jme) {
-			JptCorePlugin.log(jme);
+			return javaProject.findType(packageName, qualifiedTypeName.replace('$', '.'));
+		} catch (JavaModelException ex) {
+			JptCorePlugin.log(ex);
+			return null;
 		}
-		return null;
 	}
 
 	/**
@@ -117,7 +118,7 @@ public class JDTTools {
 	}
 
 	/**
-	 * Resolve the specified type name in the scope of the specified jdt type.
+	 * Resolve the specified type name in the scope of the specified JDT type.
 	 * Return the fully-qualified type name or return null if it cannot be
 	 * resolved unambiguously.
 	 */
@@ -149,71 +150,29 @@ public class JDTTools {
 		return Signature.getTypeSignatureKind(signature) == Signature.BASE_TYPE_SIGNATURE;
 	}
 
-	public static String resolveEnum(ICompilationUnit sourceUnit, Expression enumExpression) {
-		return resolveEnum(sourceUnit, enumExpression.getStartPosition(), enumExpression.getStartPosition() + enumExpression.getLength() - 1);
-	}
-
-	public static String resolveEnum(ICompilationUnit sourceUnit, int enumSourceStart, int enumSourceEnd) {
-		try {
-			return resolveEnum_(sourceUnit, enumSourceStart, enumSourceEnd);
-		} catch (JavaModelException ex) {
-			throw new RuntimeException(ex);
+	public static String resolveEnum(Expression expression) {
+		if (expression == null) {
+			return null;
+		}
+		switch (expression.getNodeType()) {
+			case ASTNode.QUALIFIED_NAME:
+			case ASTNode.SIMPLE_NAME:
+				return resolveEnum((Name) expression);
+			default:
+				return null;
 		}
 	}
 
-	private static String resolveEnum_(ICompilationUnit sourceUnit, int enumSourceStart, int enumSourceEnd) throws JavaModelException {
-		String[][] resolvedEnums = resolveField_((org.eclipse.jdt.internal.core.CompilationUnit) sourceUnit, enumSourceStart, enumSourceEnd);
-		// if more than one resolved enum is returned, the enum name is ambiguous
-		if (resolvedEnums == null) {
-			return null;
+	public static String resolveEnum(Name enumExpression) {
+		IBinding binding = enumExpression.resolveBinding();
+		if (binding == null) {
+			return null;  // TODO figure why this is null sometimes
 		}
-		if (resolvedEnums.length > 1) {
+		if (binding.getKind() != IBinding.VARIABLE) {
 			return null;
 		}
-		return resolvedEnums[0][0] + "." + resolvedEnums[0][1] + "." + resolvedEnums[0][2];
+		IVariableBinding variableBinding = (IVariableBinding) binding;
+		return variableBinding.getType().getQualifiedName() + "." + variableBinding.getName();
 	}
 
-	// code lifted from SourceType.resolveType(String, WorkingCopyOwner)
-	private static String[][] resolveField_(org.eclipse.jdt.internal.core.CompilationUnit sourceUnit, int selectionSourceStart, int selectionSourceEnd) throws JavaModelException {
-		class TypeResolveRequestor implements ISelectionRequestor {
-			String[][] answers = null;
-			public void acceptType(char[] packageName, char[] tName, int modifiers, boolean isDeclaration, char[] uniqueKey, int start, int end) {
-				// ignore
-			}
-			public void acceptError(CategorizedProblem error) {
-				// ignore
-			}
-			public void acceptField(char[] declaringTypePackageName, char[] declaringTypeName, char[] fieldName, boolean isDeclaration, char[] uniqueKey, int start, int end) {
-				String[] answer = new String[]  {new String(declaringTypePackageName), new String(declaringTypeName), new String(fieldName) };
-				if (this.answers == null) {
-					this.answers = new String[][]{ answer };
-				} else {
-					int len = this.answers.length;
-					System.arraycopy(this.answers, 0, this.answers = new String[len+1][], 0, len);
-					this.answers[len] = answer;
-				}
-			}
-			public void acceptMethod(char[] declaringTypePackageName, char[] declaringTypeName, String enclosingDeclaringTypeSignature, char[] selector, char[][] parameterPackageNames, char[][] parameterTypeNames, String[] parameterSignatures, char[][] typeParameterNames, char[][][] typeParameterBoundNames, boolean isConstructor, boolean isDeclaration, char[] uniqueKey, int start, int end) {
-				// ignore
-			}
-			public void acceptPackage(char[] packageName){
-				// ignore
-			}
-			public void acceptTypeParameter(char[] declaringTypePackageName, char[] declaringTypeName, char[] typeParameterName, boolean isDeclaration, int start, int end) {
-				// ignore
-			}
-			public void acceptMethodTypeParameter(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, int selectorStart, int selcetorEnd, char[] typeParameterName, boolean isDeclaration, int start, int end) {
-				// ignore
-			}
-	
-		}
-		TypeResolveRequestor requestor = new TypeResolveRequestor();
-		JavaProject project = (JavaProject) sourceUnit.getJavaProject();
-		SearchableEnvironment environment = project.newSearchableNameEnvironment(DefaultWorkingCopyOwner.PRIMARY);
-	
-		SelectionEngine engine = new SelectionEngine(environment, requestor, project.getOptions(true));
-			
-		engine.select(sourceUnit, selectionSourceStart, selectionSourceEnd);
-		return requestor.answers;
-	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/Member.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/Member.java
index 2ea7212704..e1ee7ec053 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/Member.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/Member.java
@@ -96,7 +96,14 @@ public abstract class Member {
 	 * note: this creates a *new* AST
 	 */
 	public CompilationUnit astRoot() {
-		return JDTTools.createASTRoot(this.jdtMember);
+		return JDTTools.buildASTRoot(this.jdtMember);
+	}
+
+	/**
+	 * note: this creates a *new* AST
+	 */
+	private CompilationUnit lightweightASTRoot() {
+		return JDTTools.buildLightweightASTRoot(this.jdtMember);
 	}
 
 	public ModifiedDeclaration modifiedDeclaration() {
@@ -112,7 +119,7 @@ public abstract class Member {
 	}
 
 	public ITextRange textRange() {
-		return this.textRange(this.astRoot());
+		return this.textRange(this.lightweightASTRoot());
 	}
 
 	public ITextRange textRange(CompilationUnit astRoot) {
@@ -124,23 +131,23 @@ public abstract class Member {
 	}
 
 	public ITextRange nameTextRange() {
-		return this.nameTextRange(this.astRoot());
+		return this.nameTextRange(this.lightweightASTRoot());
 	}
 	
 	public ITextRange nameTextRange(CompilationUnit astRoot) {
 		ISourceRange sourceRange = this.nameSourceRange();
-		return 
+		return
 			new SimpleTextRange(
 				sourceRange.getOffset(), 
 				sourceRange.getLength(),
-				astRoot.getLineNumber(sourceRange.getOffset()));
+				astRoot.getLineNumber(sourceRange.getOffset())
+			);
 	}
 	
 	private ISourceRange nameSourceRange() {
 		try {
-			return getJdtMember().getNameRange();
-		}
-		catch (JavaModelException ex) {
+			return this.jdtMember.getNameRange();
+		} catch (JavaModelException ex) {
 			throw new RuntimeException(ex);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ModifiedDeclaration.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ModifiedDeclaration.java
index 18c85208fe..9af69a287f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ModifiedDeclaration.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/ModifiedDeclaration.java
@@ -20,6 +20,7 @@ import org.eclipse.jdt.core.dom.Annotation;
 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.ITypeBinding;
 import org.eclipse.jdt.core.dom.ImportDeclaration;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
@@ -71,7 +72,7 @@ public class ModifiedDeclaration {
 	 * Return the "declaration" AST node.
 	 */
 	public ASTNode getDeclaration() {
-		return this.adapter.getDeclaration();
+		return this.adapter.declaration();
 	}
 
 	/**
@@ -277,19 +278,30 @@ public class ModifiedDeclaration {
 	}
 
 	private String qualifiedName(Annotation annotation) {
-		String name = annotation.getTypeName().getFullyQualifiedName();
-		if (name.indexOf('.') != -1) {
-			return name;  // name is already qualified
-		}
-		String resolvedName = JDTTools.resolve(name, this.type());
-		if (resolvedName != null) {
-			return resolvedName;
+		ITypeBinding typeBinding = annotation.resolveTypeBinding();
+		if (typeBinding != null) {
+			String resolvedName = typeBinding.getQualifiedName();
+			if (resolvedName != null) {
+				return resolvedName;
+			}
 		}
 		// hack(?): check for a matching import because when moving a stand-alone
 		// annotation to its container in CombinationIndexedDeclarationAnnotationAdapter
 		// the container's import is added but then it won't "resolve" upon
 		// subsequent lookups... :-(
-		return this.importFor(name);  // look for a matching import
+		return this.importFor(annotation.getTypeName().getFullyQualifiedName());  // look for a matching import
+
+		// OLD METHOD SOURCE:
+//		String name = annotation.getTypeName().getFullyQualifiedName();
+//		if (name.indexOf('.') != -1) {
+//			return name;  // name is already qualified
+//		}
+//		String resolvedName = JDTTools.resolve(name, this.type());
+//		// hack(?): check for a matching import because when moving a stand-alone
+//		// annotation to its container in CombinationIndexedDeclarationAnnotationAdapter
+//		// the container's import is added but then it won't "resolve" upon
+//		// subsequent lookups... :-(
+//		return this.importFor(name);  // look for a matching import
 	}
 
 	/**
@@ -353,7 +365,7 @@ public class ModifiedDeclaration {
 		/**
 		 * Return the adapted "declaration".
 		 */
-		ASTNode getDeclaration();
+		ASTNode declaration();
 
 		/**
 		 * Return the "declaration"'s list of modifiers.
@@ -369,7 +381,7 @@ public class ModifiedDeclaration {
 			super();
 			this.declaration = declaration;
 		}
-		public ASTNode getDeclaration() {
+		public ASTNode declaration() {
 			return this.declaration;
 		}
 		@SuppressWarnings("unchecked")
@@ -388,7 +400,7 @@ public class ModifiedDeclaration {
 			super();
 			this.declaration = declaration;
 		}
-		public ASTNode getDeclaration() {
+		public ASTNode declaration() {
 			return this.declaration;
 		}
 		@SuppressWarnings("unchecked")
@@ -407,7 +419,7 @@ public class ModifiedDeclaration {
 			super();
 			this.declaration = declaration;
 		}
-		public ASTNode getDeclaration() {
+		public ASTNode declaration() {
 			return this.declaration;
 		}
 		@SuppressWarnings("unchecked")
@@ -426,7 +438,7 @@ public class ModifiedDeclaration {
 			super();
 			this.declaration = declaration;
 		}
-		public ASTNode getDeclaration() {
+		public ASTNode declaration() {
 			return this.declaration;
 		}
 		@SuppressWarnings("unchecked")
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NameStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NameStringExpressionConverter.java
index 078835e845..0aaa703172 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NameStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NameStringExpressionConverter.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.Name;
 
 /**
@@ -18,14 +19,14 @@ import org.eclipse.jdt.core.dom.Name;
  * (e.g. "com.xxx.Foo.VALUE1" or "value").
  */
 public final class NameStringExpressionConverter
-	extends AbstractExpressionConverter<String, Name>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, Name> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, Name> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new NameStringExpressionConverter();
 		}
@@ -40,16 +41,16 @@ public final class NameStringExpressionConverter
 	}
 
 	@Override
-	protected Name convert_(String string, AST ast) {
+	protected Name convertObject(String string, AST ast) {
 		return ast.newName(string);
 	}
 
 	@Override
-	protected String convert_(Name name) {
-		switch (name.getNodeType()) {
+	protected String convertExpression(Expression expression) {
+		switch (expression.getNodeType()) {
 			case ASTNode.QUALIFIED_NAME:
 			case ASTNode.SIMPLE_NAME:
-				return name.getFullyQualifiedName();
+				return ((Name) expression).getFullyQualifiedName();
 			default:
 				return null;
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NullExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NullExpressionConverter.java
index e58f3af09b..b45c0ce64c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NullExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NullExpressionConverter.java
@@ -17,16 +17,16 @@ import org.eclipse.jpt.utility.internal.StringTools;
  * No conversion.
  */
 public final class NullExpressionConverter
-	implements ExpressionConverter<Expression, Expression>
+	implements ExpressionConverter<Expression>
 {
 
 	// singleton
-	private static ExpressionConverter<Expression, Expression> INSTANCE = new NullExpressionConverter();
+	private static ExpressionConverter<Expression> INSTANCE = new NullExpressionConverter();
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<Expression, Expression> instance() {
+	public static ExpressionConverter<Expression> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new NullExpressionConverter();
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NumberStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NumberStringExpressionConverter.java
index 0b312fb720..ead2da9168 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NumberStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/NumberStringExpressionConverter.java
@@ -10,7 +10,7 @@
 package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
-import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.NumberLiteral;
 
 /**
@@ -18,14 +18,14 @@ import org.eclipse.jdt.core.dom.NumberLiteral;
  * (e.g. "48").
  */
 public final class NumberStringExpressionConverter
-	extends AbstractExpressionConverter<String, NumberLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, NumberLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, NumberLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new NumberStringExpressionConverter();
 		}
@@ -40,16 +40,14 @@ public final class NumberStringExpressionConverter
 	}
 	
 	@Override
-	protected NumberLiteral convert_(String string, AST ast) {
+	protected NumberLiteral convertObject(String string, AST ast) {
 		return ast.newNumberLiteral(string);
 	}
 
 	@Override
-	protected String convert_(NumberLiteral numberLiteral) {
-		return (numberLiteral.getNodeType() == ASTNode.NUMBER_LITERAL) ?
-			numberLiteral.getToken()
-		:
-			null;
+	protected String convertExpression(Expression expression) {
+		Object value = expression.resolveConstantExpressionValue();
+		return (value instanceof Number) ? ((Number) value).toString() : null;
 	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/PrimitiveTypeStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/PrimitiveTypeStringExpressionConverter.java
index 49f6d99166..910d735492 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/PrimitiveTypeStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/PrimitiveTypeStringExpressionConverter.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.PrimitiveType;
 import org.eclipse.jdt.core.dom.TypeLiteral;
 
@@ -19,14 +20,14 @@ import org.eclipse.jdt.core.dom.TypeLiteral;
  * (e.g. "int").
  */
 public final class PrimitiveTypeStringExpressionConverter
-	extends AbstractExpressionConverter<String, TypeLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, TypeLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, TypeLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new PrimitiveTypeStringExpressionConverter();
 		}
@@ -41,7 +42,7 @@ public final class PrimitiveTypeStringExpressionConverter
 	}
 
 	@Override
-	protected TypeLiteral convert_(String string, AST ast) {
+	protected TypeLiteral convertObject(String string, AST ast) {
 		org.eclipse.jdt.core.dom.Type type = ast.newPrimitiveType(PrimitiveType.toCode(string));
 		TypeLiteral typeLiteral = ast.newTypeLiteral();
 		typeLiteral.setType(type);
@@ -49,9 +50,9 @@ public final class PrimitiveTypeStringExpressionConverter
 	}
 
 	@Override
-	protected String convert_(TypeLiteral typeLiteral) {
-		if (typeLiteral.getNodeType() == ASTNode.TYPE_LITERAL) {
-			org.eclipse.jdt.core.dom.Type type = typeLiteral.getType();
+	protected String convertExpression(Expression expression) {
+		if (expression.getNodeType() == ASTNode.TYPE_LITERAL) {
+			org.eclipse.jdt.core.dom.Type type = ((TypeLiteral) expression).getType();
 			if (type.getNodeType() == ASTNode.PRIMITIVE_TYPE) {
 				return ((PrimitiveType) type).getPrimitiveTypeCode().toString();
 			}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/SimpleTypeStringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/SimpleTypeStringExpressionConverter.java
index 43566cb864..e596a33a94 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/SimpleTypeStringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/SimpleTypeStringExpressionConverter.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.SimpleType;
 import org.eclipse.jdt.core.dom.TypeLiteral;
@@ -20,14 +21,14 @@ import org.eclipse.jdt.core.dom.TypeLiteral;
  * (e.g. "java.lang.Object").
  */
 public final class SimpleTypeStringExpressionConverter
-	extends AbstractExpressionConverter<String, TypeLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, TypeLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, TypeLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new SimpleTypeStringExpressionConverter();
 		}
@@ -42,7 +43,7 @@ public final class SimpleTypeStringExpressionConverter
 	}
 
 	@Override
-	protected TypeLiteral convert_(String string, AST ast) {
+	protected TypeLiteral convertObject(String string, AST ast) {
 		Name name = ast.newName(string);
 		org.eclipse.jdt.core.dom.Type type = ast.newSimpleType(name);
 		TypeLiteral typeLiteral = ast.newTypeLiteral();
@@ -51,9 +52,9 @@ public final class SimpleTypeStringExpressionConverter
 	}
 
 	@Override
-	protected String convert_(TypeLiteral typeLiteral) {
-		if (typeLiteral.getNodeType() == ASTNode.TYPE_LITERAL) {
-			org.eclipse.jdt.core.dom.Type type = typeLiteral.getType();
+	protected String convertExpression(Expression expression) {
+		if (expression.getNodeType() == ASTNode.TYPE_LITERAL) {
+			org.eclipse.jdt.core.dom.Type type = ((TypeLiteral) expression).getType();
 			if (type.getNodeType() == ASTNode.SIMPLE_TYPE) {
 				return ((SimpleType) type).getName().getFullyQualifiedName();
 			}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringArrayExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringArrayExpressionConverter.java
index 02d081ab7b..31d61abcf6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringArrayExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringArrayExpressionConverter.java
@@ -10,23 +10,28 @@
 package org.eclipse.jpt.core.internal.jdtutility;
 
 import java.util.List;
+
 import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ArrayInitializer;
 import org.eclipse.jdt.core.dom.Expression;
 
 /**
  * Convert an array initializer to/from an array of strings (e.g. {"text0", "text1"}).
- * E is the type of the expressions to be found in the array initializer.
  * 
  * Do NOT use this class for converting array initializers in annotation elements.
  * Java5 has a bit of syntactic sugar that allows a single-element array
- * initializer to not have curly braces. This converter will barf if it encounters
+ * initializer to not have curly braces. This converter will return null if it encounters
  * anything other than an array initializer.
+ * 
+ * Invalid entries in the array initializer will result in null elements in the
+ * resulting string array. This allows clients to manipulate elements at
+ * the appropriate index.
  */
-public class StringArrayExpressionConverter<E extends Expression>
-	extends AbstractExpressionConverter<String[], ArrayInitializer>
+public class StringArrayExpressionConverter
+	extends AbstractExpressionConverter<String[]>
 {
-	private final ExpressionConverter<String, E> elementConverter;
+	private final ExpressionConverter<String> elementConverter;
 	private final boolean removeArrayInitializerWhenEmpty;
 
 	private static final String[] EMPTY_STRING_ARRAY = new String[0];
@@ -35,11 +40,11 @@ public class StringArrayExpressionConverter<E extends Expression>
 	/**
 	 * The default behavior is to remove the array initializer if it is empty.
 	 */
-	public StringArrayExpressionConverter(ExpressionConverter<String, E> elementConverter) {
+	public StringArrayExpressionConverter(ExpressionConverter<String> elementConverter) {
 		this(elementConverter, true);
 	}
 
-	public StringArrayExpressionConverter(ExpressionConverter<String, E> elementConverter, boolean removeArrayInitializerWhenEmpty) {
+	public StringArrayExpressionConverter(ExpressionConverter<String> elementConverter, boolean removeArrayInitializerWhenEmpty) {
 		super();
 		this.elementConverter = elementConverter;
 		this.removeArrayInitializerWhenEmpty = removeArrayInitializerWhenEmpty;
@@ -50,7 +55,7 @@ public class StringArrayExpressionConverter<E extends Expression>
 	 * this method is 'public' so it can be called by
 	 * AnnotationStringArrayExpressionConverter
 	 */
-	public ArrayInitializer convert_(String[] strings, AST ast) {
+	public ArrayInitializer convertObject(String[] strings, AST ast) {
 		if ((strings.length == 0) && this.removeArrayInitializerWhenEmpty) {
 			return null;
 		}
@@ -67,21 +72,29 @@ public class StringArrayExpressionConverter<E extends Expression>
 		return arrayInitializer.expressions();
 	}
 
-	@Override
 	/*
 	 * this method is 'public' so it can be called by
 	 * AnnotationStringArrayExpressionConverter
 	 */
+	@Override
 	public String[] convertNull() {
 		return EMPTY_STRING_ARRAY;
 	}
 
 	@Override
+	protected String[] convertExpression(Expression expression) {
+		return (expression.getNodeType() == ASTNode.ARRAY_INITIALIZER) ?
+				this.convertArrayInitializer((ArrayInitializer) expression)
+			:
+				EMPTY_STRING_ARRAY;
+	}
+
 	/*
-	 * 'public' in support of AnnotationStringArrayExpressionConverter
+	 * this method is 'public' so it can be called by
+	 * AnnotationStringArrayExpressionConverter
 	 */
-	public String[] convert_(ArrayInitializer arrayInitializer) {
-		List<E> expressions = this.downcastExpressions(arrayInitializer);
+	public String[] convertArrayInitializer(ArrayInitializer arrayInitializer) {
+		List<Expression> expressions = this.downcastExpressions(arrayInitializer);
 		int len = expressions.size();
 		String[] strings = new String[len];
 		for (int i = len; i-- > 0; ) {
@@ -91,7 +104,7 @@ public class StringArrayExpressionConverter<E extends Expression>
 	}
 
 	@SuppressWarnings("unchecked")
-	private List<E> downcastExpressions(ArrayInitializer arrayInitializer) {
+	private List<Expression> downcastExpressions(ArrayInitializer arrayInitializer) {
 		return arrayInitializer.expressions();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringExpressionConverter.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringExpressionConverter.java
index 444650f53e..9560ca286f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringExpressionConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jdtutility/StringExpressionConverter.java
@@ -10,21 +10,21 @@
 package org.eclipse.jpt.core.internal.jdtutility;
 
 import org.eclipse.jdt.core.dom.AST;
-import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.StringLiteral;
 
 /**
  * Convert a string literal to/from a string (e.g. "text").
  */
 public final class StringExpressionConverter
-	extends AbstractExpressionConverter<String, StringLiteral>
+	extends AbstractExpressionConverter<String>
 {
-	private static ExpressionConverter<String, StringLiteral> INSTANCE;
+	private static ExpressionConverter<String> INSTANCE;
 
 	/**
 	 * Return the singleton.
 	 */
-	public static ExpressionConverter<String, StringLiteral> instance() {
+	public static ExpressionConverter<String> instance() {
 		if (INSTANCE == null) {
 			INSTANCE = new StringExpressionConverter();
 		}
@@ -39,18 +39,16 @@ public final class StringExpressionConverter
 	}
 
 	@Override
-	protected StringLiteral convert_(String string, AST ast) {
+	protected StringLiteral convertObject(String string, AST ast) {
 		StringLiteral stringLiteral = ast.newStringLiteral();
 		stringLiteral.setLiteralValue(string);
 		return stringLiteral;
 	}
 
 	@Override
-	protected String convert_(StringLiteral stringLiteral) {
-		return (stringLiteral.getNodeType() == ASTNode.STRING_LITERAL) ?
-			stringLiteral.getLiteralValue()
-		:
-			null;
+	protected String convertExpression(Expression expression) {
+		Object value = expression.resolveConstantExpressionValue();
+		return (value instanceof String) ? (String) value : null;
 	}
 
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/JDTToolsTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/JDTToolsTests.java
index 5176595367..1e22611a3b 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/JDTToolsTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/JDTToolsTests.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.tests.internal.jdtutility;
 
 import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jpt.core.internal.jdtutility.ConversionDeclarationAnnotationElementAdapter;
 import org.eclipse.jpt.core.internal.jdtutility.DeclarationAnnotationAdapter;
 import org.eclipse.jpt.core.internal.jdtutility.DeclarationAnnotationElementAdapter;
@@ -118,7 +119,7 @@ public class JDTToolsTests extends AnnotationTestCase {
 		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "foo");
 		FieldAttribute field = this.idField();
 
-		String actual = JDTTools.resolveEnum(this.jdtType().getCompilationUnit(), field.annotationElementExpression(daea));
+		String actual = JDTTools.resolveEnum((Name) field.annotationElementExpression(daea));
 		assertEquals("enums.TestEnum.BAZ", actual);
 	}
 
@@ -131,7 +132,7 @@ public class JDTToolsTests extends AnnotationTestCase {
 		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "foo");
 		FieldAttribute field = this.idField();
 
-		String actual = JDTTools.resolveEnum(this.jdtType().getCompilationUnit(), field.annotationElementExpression(daea));
+		String actual = JDTTools.resolveEnum((Name) field.annotationElementExpression(daea));
 		assertEquals("enums.TestEnum.BAZ", actual);
 	}
 
@@ -144,7 +145,7 @@ public class JDTToolsTests extends AnnotationTestCase {
 		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "foo");
 		FieldAttribute field = this.idField();
 
-		String actual = JDTTools.resolveEnum(this.jdtType().getCompilationUnit(), field.annotationElementExpression(daea));
+		String actual = JDTTools.resolveEnum((Name) field.annotationElementExpression(daea));
 		assertEquals("enums.TestEnum.BAZ", actual);
 	}
 
@@ -157,7 +158,7 @@ public class JDTToolsTests extends AnnotationTestCase {
 		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "foo");
 		FieldAttribute field = this.idField();
 
-		String actual = JDTTools.resolveEnum(this.jdtType().getCompilationUnit(), field.annotationElementExpression(daea));
+		String actual = JDTTools.resolveEnum((Name) field.annotationElementExpression(daea));
 		assertEquals("enums.TestEnum.BAZ", actual);
 	}
 
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/MemberAnnotationElementAdapterTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/MemberAnnotationElementAdapterTests.java
index 9f16dc1086..b07c31488a 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/MemberAnnotationElementAdapterTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jdtutility/MemberAnnotationElementAdapterTests.java
@@ -11,12 +11,6 @@ package org.eclipse.jpt.core.tests.internal.jdtutility;
 
 import java.util.Arrays;
 
-import org.eclipse.jdt.core.dom.BooleanLiteral;
-import org.eclipse.jdt.core.dom.CharacterLiteral;
-import org.eclipse.jdt.core.dom.Expression;
-import org.eclipse.jdt.core.dom.NumberLiteral;
-import org.eclipse.jdt.core.dom.StringLiteral;
-import org.eclipse.jdt.core.dom.TypeLiteral;
 import org.eclipse.jpt.core.internal.ITextRange;
 import org.eclipse.jpt.core.internal.jdtutility.ASTNodeTextRange;
 import org.eclipse.jpt.core.internal.jdtutility.AnnotationElementAdapter;
@@ -65,7 +59,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "int bar();");
 		this.createTestType("@annot.Foo(bar=48)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, NumberLiteral>(daa, "bar", NumberStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", NumberStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("48", aea.getValue());
 	}
@@ -74,7 +68,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "char bar();");
 		this.createTestType("@annot.Foo(bar='c')");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, CharacterLiteral>(daa, "bar", CharacterStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", CharacterStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("c", aea.getValue());
 	}
@@ -83,7 +77,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "boolean bar();");
 		this.createTestType("@annot.Foo(bar=false)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa, "bar", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("false", aea.getValue());
 	}
@@ -96,7 +90,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("false", aea.getValue());
 	}
@@ -105,7 +99,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "boolean value();");
 		this.createTestType("@annot.Foo(false)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa, BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("false", aea.getValue());
 	}
@@ -141,6 +135,197 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		assertNull(aea.getValue());
 	}
 
+	public void testGetValueStringConcatenation() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String bar();");
+		this.createTestType("@annot.Foo(bar=\"xxx\" + \"yyy\" + \"zzz\")");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("xxxyyyzzz", aea.getValue());
+	}
+
+	public void testGetValueStringConstant() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String bar();");
+		// just a bit hacky:
+		this.createTestType("private static final String FOO_BAR = \"xxx\"; @annot.Foo(bar=FOO_BAR + \"yyy\" + \"zzz\")");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("xxxyyyzzz", aea.getValue());
+	}
+
+	public void testGetValueNumberArithmetic() throws Exception {
+		this.createAnnotationAndMembers("Foo", "int bar();");
+		this.createTestType("@annot.Foo(bar=47 - 7 + 2 * 1 / 1)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forNumbers(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("42", aea.getValue());
+	}
+
+	public void testGetValueNumberShift() throws Exception {
+		this.createAnnotationAndMembers("Foo", "int bar();");
+		this.createTestType("@annot.Foo(bar=2 << 2)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forNumbers(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("8", aea.getValue());
+	}
+
+	public void testGetValueNumberConstant() throws Exception {
+		this.createAnnotationAndMembers("Foo", "int bar();");
+		// just a bit hacky:
+		this.createTestType("private static final int FOO_BAR = 77; @annot.Foo(bar=FOO_BAR)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forNumbers(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("77", aea.getValue());
+	}
+
+	public void testGetValueCharacterConstant() throws Exception {
+		this.createAnnotationAndMembers("Foo", "char bar();");
+		// just a bit hacky:
+		this.createTestType("private static final char FOO_BAR = 'Q'; @annot.Foo(bar=FOO_BAR)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forCharacters(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("Q", aea.getValue());
+	}
+
+	public void testGetValueCharacterCast() throws Exception {
+		this.createAnnotationAndMembers("Foo", "char bar();");
+		this.createTestType("@annot.Foo(bar=(char) 0x41)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forCharacters(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("A", aea.getValue());
+	}
+
+	public void testGetValueBooleanOperator1() throws Exception {
+		this.createAnnotationAndMembers("Foo", "boolean bar();");
+		this.createTestType("@annot.Foo(bar=7 > 2)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forBooleans(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("true", aea.getValue());
+	}
+
+	public void testGetValueBooleanOperator2() throws Exception {
+		this.createAnnotationAndMembers("Foo", "boolean bar();");
+		this.createTestType("@annot.Foo(bar=7 == 2)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forBooleans(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("false", aea.getValue());
+	}
+
+	public void testGetValueBooleanOperator3() throws Exception {
+		this.createAnnotationAndMembers("Foo", "boolean bar();");
+		this.createTestType("@annot.Foo(bar=(7 != 2) && false)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forBooleans(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("false", aea.getValue());
+	}
+
+	public void testGetValueBooleanOperator4() throws Exception {
+		this.createAnnotationAndMembers("Foo", "boolean bar();");
+		this.createTestType("@annot.Foo(bar=(7 != 2) ? false : true)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forBooleans(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertEquals("false", aea.getValue());
+	}
+
+	public void testGetValueInvalidValue1() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String bar();");
+		this.createTestType("@annot.Foo(bar=77)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue2() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String bar();");
+		this.createTestType("@annot.Foo(bar=bazzzz)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forStrings(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue3() throws Exception {
+		this.createAnnotationAndMembers("Foo", "boolean bar();");
+		this.createTestType("@annot.Foo(bar=bazzzz)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forBooleans(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue4() throws Exception {
+		this.createAnnotationAndMembers("Foo", "char bar();");
+		this.createTestType("@annot.Foo(bar=\"bazzzz\")");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = ConversionDeclarationAnnotationElementAdapter.forCharacters(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue5() throws Exception {
+		this.createAnnotationAndMembers("Foo", "Class bar();");
+		this.createTestType("@annot.Foo(bar=\"java.lang.Object\")");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue6() throws Exception {
+		this.createEnum("TestEnum", "XXX, YYY, ZZZ");
+		this.createAnnotationAndMembers("Foo", "enums.TestEnum bar();");
+		this.createTestType("@annot.Foo(bar=enums.TestEnum.class)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String> daea = new EnumDeclarationAnnotationElementAdapter(daa, "bar");
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue7() throws Exception {
+		this.createAnnotationAndMembers("Baz", "boolean fred();");
+		this.createAnnotationAndMembers("Bar", "annot.Baz jimmy();");
+		this.createAnnotationAndMembers("Foo", "annot.Bar value();");
+		String value = "\"false\"";
+		String element = "fred=" + value;
+		String annotation = "@annot.Foo(@annot.Bar(jimmy=@annot.Baz(" + element + ")))";
+		this.createTestType(annotation);
+		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
+		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
+		assertNull(aea.getValue());
+	}
+
+	public void testGetValueInvalidValue8() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String[] bar();");
+		this.createTestType("@annot.Foo(bar={true, false})");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
+		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
+		assertTrue(Arrays.equals(new String[] {null, null}, aea.getValue()));
+	}
+
+	public void testGetValueInvalidValue9() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String[] bar();");
+		this.createTestType("@annot.Foo(bar=77)");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
+		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
+		assertTrue(Arrays.equals(new String[] {null}, aea.getValue()));
+	}
+
 	public void testASTNode1() throws Exception {
 		this.createAnnotationAndMembers("Foo", "String bar();");
 		String value = "\"xxx\"";
@@ -168,7 +353,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("false", aea.getValue());
 		ITextRange textRange = new ASTNodeTextRange(aea.astNode());
@@ -239,7 +424,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 
 		aea.setValue(null);
@@ -258,7 +443,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar", false);
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz", false);
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 
 		aea.setValue(null);
@@ -287,7 +472,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 
 		aea.setValue("true");
@@ -303,7 +488,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedDeclarationAnnotationAdapter(daa2, "jimmy", "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, BooleanLiteral>(daa3, "fred", BooleanStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", BooleanStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 
 		aea.setValue("true");
@@ -375,7 +560,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		DeclarationAnnotationAdapter daa1 = new SimpleDeclarationAnnotationAdapter("annot.Foo");
 		DeclarationAnnotationAdapter daa2 = new NestedDeclarationAnnotationAdapter(daa1, "value", "annot.Bar");
 		DeclarationAnnotationAdapter daa3 = new NestedIndexedDeclarationAnnotationAdapter(daa2, "jimmy", 2, "annot.Baz");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, NumberLiteral>(daa3, "fred", NumberStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa3, "fred", NumberStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 
 		assertEquals("2", aea.getValue());
@@ -414,7 +599,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=java.lang.Object.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("java.lang.Object", aea.getValue());
 	}
@@ -423,7 +608,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType();
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		aea.setValue("java.lang.Object");
 		this.assertSourceContains("@Foo(bar=java.lang.Object.class)");
@@ -433,7 +618,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=int.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertNull(aea.getValue());
 	}
@@ -442,7 +627,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=java.util.Map.Entry.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", SimpleTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("java.util.Map.Entry", aea.getValue());
 	}
@@ -451,7 +636,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=int.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("int", aea.getValue());
 	}
@@ -460,7 +645,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType();
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		aea.setValue("int");
 		this.assertSourceContains("@Foo(bar=int.class)");
@@ -470,7 +655,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=java.lang.Object.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertNull(aea.getValue());
 	}
@@ -479,7 +664,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "Class bar();");
 		this.createTestType("@annot.Foo(bar=void.class)");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String, TypeLiteral>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
+		DeclarationAnnotationElementAdapter<String> daea = new ConversionDeclarationAnnotationElementAdapter<String>(daa, "bar", PrimitiveTypeStringExpressionConverter.instance());
 		AnnotationElementAdapter<String> aea = new MemberAnnotationElementAdapter<String>(this.idField(), daea);
 		assertEquals("void", aea.getValue());
 	}
@@ -555,7 +740,16 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "String[] bar();");
 		this.createTestType("@annot.Foo(bar={\"string0\", \"string1\"})");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
+		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
+		assertTrue(Arrays.equals(new String[] {"string0", "string1"}, aea.getValue()));
+	}
+
+	public void testGetValueStringArrayConcatenation() throws Exception {
+		this.createAnnotationAndMembers("Foo", "String[] bar();");
+		this.createTestType("@annot.Foo(bar={\"stri\" + \"ng0\", \"s\" + \"tring1\"})");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		assertTrue(Arrays.equals(new String[] {"string0", "string1"}, aea.getValue()));
 	}
@@ -564,7 +758,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "String[] bar();");
 		this.createTestType("@annot.Foo(bar={})");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		assertTrue(Arrays.equals(new String[0], aea.getValue()));
 	}
@@ -573,7 +767,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "String[] bar();");
 		this.createTestType("@annot.Foo(bar=\"string0\")");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		assertTrue(Arrays.equals(new String[] {"string0"}, aea.getValue()));
 	}
@@ -582,7 +776,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createAnnotationAndMembers("Foo", "String[] bar();");
 		this.createTestType("@annot.Foo()");
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		assertTrue(Arrays.equals(new String[0], aea.getValue()));
 	}
@@ -593,7 +787,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createTestType();
 		this.assertSourceDoesNotContain(annotation);
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		aea.setValue(new String[] {"string0", "string1"});
 		this.assertSourceContains(annotation);
@@ -605,7 +799,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createTestType();
 		this.assertSourceDoesNotContain(annotation);
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		aea.setValue(new String[0]);
 		this.assertSourceDoesNotContain(annotation);
@@ -617,8 +811,8 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createTestType();
 		this.assertSourceDoesNotContain(annotation);
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		ExpressionConverter<String[], Expression> expressionConverter = new AnnotationStringArrayExpressionConverter<StringLiteral>(StringExpressionConverter.instance(), false);
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", expressionConverter);
+		ExpressionConverter<String[]> expressionConverter = new AnnotationStringArrayExpressionConverter(StringExpressionConverter.instance(), false);
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", expressionConverter);
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		aea.setValue(new String[0]);
 		this.assertSourceContains(annotation);
@@ -630,7 +824,7 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		this.createTestType();
 		this.assertSourceDoesNotContain(annotation);
 		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
-		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[], Expression>(daa, "bar", AnnotationStringArrayExpressionConverter.forStringLiterals());
+		DeclarationAnnotationElementAdapter<String[]> daea = new ConversionDeclarationAnnotationElementAdapter<String[]>(daa, "bar", AnnotationStringArrayExpressionConverter.forStrings());
 		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
 		aea.setValue(new String[] {"string0"});
 		this.assertSourceContains(annotation);
@@ -646,6 +840,16 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		assertTrue(Arrays.equals(new String[] {"enums.TestEnum.XXX", "enums.TestEnum.YYY"}, aea.getValue()));
 	}
 
+	public void testGetValueEnumArrayInvalidEntry() throws Exception {
+		this.createEnum("TestEnum", "XXX, YYY, ZZZ");
+		this.createAnnotationAndMembers("Foo", "enums.TestEnum[] bar();");
+		this.createTestType("@annot.Foo(bar={enums.TestEnum.XXX, 88})");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String[]> daea = new EnumArrayDeclarationAnnotationElementAdapter(daa, "bar");
+		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
+		assertTrue(Arrays.equals(new String[] {"enums.TestEnum.XXX", null}, aea.getValue()));
+	}
+
 	public void testGetValueEnumArrayEmpty() throws Exception {
 		this.createEnum("TestEnum", "XXX, YYY, ZZZ");
 		this.createAnnotationAndMembers("Foo", "enums.TestEnum[] bar();");
@@ -666,6 +870,16 @@ public class MemberAnnotationElementAdapterTests extends AnnotationTestCase {
 		assertTrue(Arrays.equals(new String[] {"enums.TestEnum.XXX"}, aea.getValue()));
 	}
 
+	public void testGetValueEnumArraySingleElementInvalid() throws Exception {
+		this.createEnum("TestEnum", "XXX, YYY, ZZZ");
+		this.createAnnotationAndMembers("Foo", "enums.TestEnum[] bar();");
+		this.createTestType("@annot.Foo(bar=\"\")");
+		DeclarationAnnotationAdapter daa = new SimpleDeclarationAnnotationAdapter("annot.Foo");
+		DeclarationAnnotationElementAdapter<String[]> daea = new EnumArrayDeclarationAnnotationElementAdapter(daa, "bar");
+		AnnotationElementAdapter<String[]> aea = new MemberAnnotationElementAdapter<String[]>(this.idField(), daea);
+		assertTrue(Arrays.equals(new String[] {null}, aea.getValue()));
+	}
+
 	public void testGetValueNullEnumArray() throws Exception {
 		this.createEnum("TestEnum", "XXX, YYY, ZZZ");
 		this.createAnnotationAndMembers("Foo", "enums.TestEnum[] bar();");