209489 - rename type refactoring participation

52 files changed, 1184 insertions, 51 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/plugin.properties b/jpa/plugins/org.eclipse.jpt.core/plugin.properties
index a021f8c23a..c0c7fd1604 100644
--- a/jpa/plugins/org.eclipse.jpt.core/plugin.properties
+++ b/jpa/plugins/org.eclipse.jpt.core/plugin.properties
@@ -50,5 +50,6 @@ JPA_VALIDATOR=JPA Validator
 JPA_DELETE_TYPE_PARTICIPANT_NAME=JPA Delete Type Participant
 JPA_DELETE_PACKAGE_OR_FOLDER_PARTICIPANT_NAME=JPA Delete Package or Folder Participant
 JPA_DELETE_MAPPING_FILE_PARTICIPANT_NAME=JPA Delete Mapping File Participant
+JPA_RENAME_TYPE_PARTICIPANT_NAME=JPA Rename Type Participant
 JPA_RENAME_MAPPING_FILE_PARTICIPANT_NAME=JPA Rename Mapping File Participant
  
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/plugin.xml b/jpa/plugins/org.eclipse.jpt.core/plugin.xml
index 367a4d4689..cde2967cad 100644
--- a/jpa/plugins/org.eclipse.jpt.core/plugin.xml
+++ b/jpa/plugins/org.eclipse.jpt.core/plugin.xml
@@ -574,6 +574,16 @@
     <extension
         point="org.eclipse.ltk.core.refactoring.renameParticipants">
         <renameParticipant
+    		class="org.eclipse.jpt.core.internal.refactoring.JpaRenameTypeParticipant"
+    		id="org.eclipse.jpt.core.ltk.jpaRenameTypeParticipant"
+    		name="%JPA_RENAME_TYPE_PARTICIPANT_NAME">
+    		<enablement>
+    			<with variable="element">
+    				<instanceof value="org.eclipse.jdt.core.IType"/>
+    			</with>
+    		</enablement>
+        </renameParticipant>
+        <renameParticipant
     		class="org.eclipse.jpt.core.internal.refactoring.JpaRenameMappingFileParticipant"
     		id="org.eclipse.jpt.core.ltk.jpaRenameMappingParticipant"
     		name="%JPA_RENAME_MAPPING_FILE_PARTICIPANT_NAME">
diff --git a/jpa/plugins/org.eclipse.jpt.core/property_files/jpa_core_refactoring.properties b/jpa/plugins/org.eclipse.jpt.core/property_files/jpa_core_refactoring.properties
index bab94698e5..dc3879158b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/property_files/jpa_core_refactoring.properties
+++ b/jpa/plugins/org.eclipse.jpt.core/property_files/jpa_core_refactoring.properties
@@ -22,6 +22,13 @@ JPA_DELETE_MAPPING_FILE_REFACTORING_CHANGE_PERSISTENCE_XML_NAME=Delete mapping f
 
 JPA_REFACORING_PARTICIPANT_LOADING_JPA_PROJECTS_SUB_TASK_NAME=loading JPA projects
 
+JPA_RENAME_TYPE_REFACTORING_PARTICIPANT_NAME=JPA rename IType refactoring participant
+JPA_RENAME_PACKAGE_REFACTORING_PARTICIPANT_NAME=JPA rename IPackageFragment refactoring participant
+JPA_RENAME_TYPE_REFACTORING_CHANGE_NAME=Rename classes referenced in JPA metadata files
+JPA_RENAME_TYPE_REFACTORING_CHANGE_PERSISTENCE_XML_NAME=Rename type references in the persistence.xml
+JPA_RENAME_TYPE_REFACTORING_CHANGE_MAPPING_FILE_NAME=Rename type references in the mapping file
+JPA_RENAME_TYPE_REFACTORING_SUB_TASK_NAME=JPA rename type references
+
 JPA_RENAME_MAPPING_FILE_REFACTORING_PARTICIPANT_NAME=JPA rename mapping file refactoring participant
 JPA_RENAME_MAPPING_FILE_REFACTORING_SUB_TASK_NAME=JPA rename mapping file references
 JPA_RENAME_MAPPING_FILE_REFACTORING_CHANGE_NAME=Rename mapping file references in JPA metadata files
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFile.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFile.java
index b8c7e4a331..b8c31e786d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFile.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFile.java
@@ -13,6 +13,7 @@ import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
 import org.eclipse.jpt.core.context.persistence.PersistentTypeContainer;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * JPA mapping file (typically <code>orm.xml</code>).
@@ -60,4 +61,10 @@ public interface MappingFile
 	 */
 	Iterable<DeleteEdit> createDeleteTypeEdits(IType type);
 
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
index 580b01f628..ff159afff7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
@@ -12,7 +12,6 @@ package org.eclipse.jpt.core.context;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
@@ -26,7 +25,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  * 
- * @version 2.3
+ * @version 3.0
  * @since 2.0
  */
 public interface PersistentType
@@ -161,6 +160,15 @@ public interface PersistentType
 	void validate(List<IMessage> messages, IReporter reporter);
 
 
+	// ********** misc **********
+
+	/**
+	 * Return whether the persistent type applies to the
+	 * specified type name qualified with '.'.
+	 */
+	boolean isFor(String typeName);
+
+
 	// ********** owner **********
 
 	/**
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/EntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/EntityMappings.java
index 44825e9741..e1f17c864d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/EntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/EntityMappings.java
@@ -22,6 +22,7 @@ import org.eclipse.jpt.db.Schema;
 import org.eclipse.jpt.db.SchemaContainer;
 import org.eclipse.jpt.utility.internal.iterables.ListIterable;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Context <code>orm.xml</code> entity mappings.
@@ -178,4 +179,10 @@ public interface EntityMappings
 	 */
 	Iterable<DeleteEdit> createDeleteTypeEdits(IType type);
 
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
index 041497ffdc..550ee7604a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
@@ -9,11 +9,13 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.orm;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.resource.orm.Attributes;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * 
@@ -24,7 +26,7 @@ import org.eclipse.jpt.core.utility.TextRange;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  * 
- * @version 2.2
+ * @version 3.0
  * @since 2.3
  */
 public interface OrmAttributeMapping
@@ -92,4 +94,13 @@ public interface OrmAttributeMapping
 	 */
 	void update();
 
+
+	//******************* refactoring *******************
+
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmIdClassReference.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmIdClassReference.java
index 29130b5174..cee22a365d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmIdClassReference.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmIdClassReference.java
@@ -10,9 +10,11 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.context.orm;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.IdClassReference;
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.context.java.JavaIdClassReference;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Provisional API: This interface is part of an interim API that is still
@@ -21,11 +23,20 @@ import org.eclipse.jpt.core.context.java.JavaIdClassReference;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  * 
- * @version 2.3
+ * @version 3.0
  * @since 2.3
  */
 public interface OrmIdClassReference
 	extends IdClassReference, XmlContextNode
 {
 	void update(JavaIdClassReference javaIdClassReference);
+
+
+	// ********** refactoring **********
+
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceEdits(IType originalType, String newName);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentAttribute.java
index 6d4a9ee181..256a022df1 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentAttribute.java
@@ -9,9 +9,11 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.orm;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.PersistentAttribute;
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * ORM persistent attribute
@@ -22,7 +24,7 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  * 
- * @version 2.3
+ * @version 3.0
  * @since 2.0
  */
 public interface OrmPersistentAttribute
@@ -79,12 +81,6 @@ public interface OrmPersistentAttribute
 	 */
 	void makeSpecified(String mappingKey);
 	
-
-	// ********** miscellaneous **********
-
-	boolean contains(int textOffset);
-
-	void nameChanged(String oldName, String newName);
 	
 	// ********** updating **********
 	
@@ -93,8 +89,24 @@ public interface OrmPersistentAttribute
 	 * resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}
 	 */
 	void update();
-	
-	
+
+
+	// ********** refactoring **********
+
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
+
+	// ********** miscellaneous **********
+
+	boolean contains(int textOffset);
+
+	void nameChanged(String oldName, String newName);
+
+
 	/**
 	 * interface allowing persistent attributes to be used in multiple places
 	 * (e.g. virtual and specified orm persistent attributes)
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentType.java
index 61a2792bc2..b0a25e8c91 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmPersistentType.java
@@ -15,6 +15,7 @@ import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Context <code>orm.xml</code> persistent type.
@@ -130,16 +131,16 @@ public interface OrmPersistentType
 	 */
 	Iterable<DeleteEdit> createDeleteTypeEdits(IType type);
 
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 
 	//******************* misc *******************
 
 	boolean contains(int textOffset);
-
-	/**
-	 * Return whether the persistent type applies to the
-	 * specified type.
-	 */
-	boolean isFor(String typeName);
 	
 	void classChanged(String oldClass, String newClass);
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmTypeMapping.java
index b71048f5c8..882062f0aa 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmTypeMapping.java
@@ -11,12 +11,14 @@ package org.eclipse.jpt.core.context.orm;
 
 import java.util.Iterator;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.TypeMapping;
 import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
 import org.eclipse.jpt.core.resource.orm.XmlTypeMapping;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * 
@@ -90,6 +92,13 @@ public interface OrmTypeMapping
 	 */
 	DeleteEdit createDeleteEdit();
 
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
+
 	// ********** covariant overrides **********
 
 	OrmPersistentType getPersistentType();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/ClassRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/ClassRef.java
index f4263974ba..31a0e0fb48 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/ClassRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/ClassRef.java
@@ -16,6 +16,7 @@ import org.eclipse.jpt.core.context.XmlContextNode;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.resource.persistence.XmlJavaClassRef;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Context model corresponding to the XML resource model
@@ -110,6 +111,13 @@ public interface ClassRef
 	 */
 	Iterable<DeleteEdit> createDeleteTypeEdits(IType type);
 
+	/**
+	 * Create ReplaceEdits for renaming the class element to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 * If this ClassRef does not match the original type, then return an empty Iterable.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 
 	// *************************************************************************
 	
@@ -118,5 +126,5 @@ public interface ClassRef
 	 * the given text offset
 	 */
 	boolean containsOffset(int textOffset);
-	
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
index 44cf3ac8ce..8be104fb3e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
@@ -136,6 +136,12 @@ public interface MappingFileRef
 	Iterable<DeleteEdit> createDeleteMappingFileEdits(IFile file);
 
 	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
+	/**
 	 * If this {@link MappingFileRef#isFor(IFile)} the given IFile, create a text 
 	 * ReplaceEdit for renaming the mapping file element to the new name.
 	 * Otherwise return an EmptyIterable.
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
index ab06f4d4db..3f17be91ce 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
@@ -429,6 +429,13 @@ public interface PersistenceUnit
 	Property getProperty(String propertyName);
 
 	/**
+	 * Return all the properties in the persistence unit with the specified 
+	 * name. Return an empty Iterable if the persistence unit does not contain 
+	 * a property with the specified name.
+	 */
+	Iterable<Property> getPropertiesNamed(String propertyName);
+
+	/**
 	 * Return the persistence unit's properties with names beginning with the
 	 * specified prefix.
 	 */
@@ -510,6 +517,13 @@ public interface PersistenceUnit
 
 		XmlProperty getXmlProperty();
 		void update();
+
+		/**
+		 * Create ReplaceEdits for renaming the property value to the newName.
+		 * The originalType has not yet been renamed, the newName is the new short name.
+		 * If this value does not match the original type, then return an empty Iterable.
+		 */
+		Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
 	}
 
 	// ********** ORM persistence unit defaults **********
@@ -727,6 +741,12 @@ public interface PersistenceUnit
 	Iterable<DeleteEdit> createDeleteMappingFileEdits(IFile file);
 
 	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
+	/**
 	 * Create ReplaceEdits for renaming any references to the originalFile to the newName.
 	 * Return an EmptyIterable if there are not any references.	
 	 * The originalFile has not yet been renamed, the newName is the new short name.
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnitProperties.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnitProperties.java
index ec987bc355..c53c1918af 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnitProperties.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnitProperties.java
@@ -9,8 +9,10 @@
 *******************************************************************************/
 package org.eclipse.jpt.core.context.persistence;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.JpaProject;
 import org.eclipse.jpt.utility.model.Model;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Provisional API: This interface is part of an interim API that is still
@@ -19,7 +21,7 @@ import org.eclipse.jpt.utility.model.Model;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  * 
- * @version 2.3
+ * @version 3.0
  * @since 2.3
  */
 public interface PersistenceUnitProperties extends Model
@@ -54,4 +56,13 @@ public interface PersistenceUnitProperties extends Model
 	 */
 	void propertyRemoved(String propertyName);
 
+
+	// ************ refactoring **************
+
+	/**
+	 * Create ReplaceEdits for renaming any references to the originalType to the newName.
+	 * The originalType has not yet been renamed, the newName is the new short name.
+	 */
+	Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName);
+
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentType.java
index c3be5d891e..bc32d52603 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentType.java
@@ -632,6 +632,11 @@ public abstract class AbstractJavaPersistentType
 
 	// ********** misc **********
 
+	public boolean isFor(String typeName) {
+		String className = this.getName();
+		return className != null && className.equals(typeName);
+	}
+
 	public boolean isMapped() {
 		return this.mapping.isMapped();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
index efabd0ad54..95dc7f6498 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
@@ -55,6 +55,7 @@ import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
 import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -828,6 +829,16 @@ public abstract class AbstractEntityMappings
 		);
 	}
 
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(final IType originalType, final String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<OrmPersistentType, Iterable<ReplaceEdit>>(getPersistentTypes()) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(OrmPersistentType persistentType) {
+					return persistentType.createReplaceTypeEdits(originalType, newName);
+				}
+			}
+		);
+	}
 
 	// ********** dispose **********
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
index ed650203bb..ad10143e0b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.Column;
 import org.eclipse.jpt.core.context.ColumnMapping;
@@ -50,8 +51,10 @@ import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -345,6 +348,13 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 	}
 
 
+	// ********** refactoring **********
+
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return EmptyIterable.instance();
+	}
+
+
 	// ********** validation **********
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
index e25a980363..725946ccda 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
@@ -15,6 +15,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.JpaPlatformVariation.Supported;
 import org.eclipse.jpt.core.context.AssociationOverride;
@@ -94,6 +95,7 @@ import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -1560,8 +1562,23 @@ public abstract class AbstractOrmEntity
 	public void removeFromResourceModel(XmlEntityMappings entityMappings) {
 		entityMappings.getEntities().remove(this.resourceTypeMapping);
 	}
-	
-	
+
+
+	//************************* refactoring ************************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+					super.createReplaceTypeEdits(originalType, newName),
+					this.createIdClassReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createIdClassReplaceTypeEdits(IType originalType, String newName) {
+		return this.idClassReference.createReplaceEdits(originalType, newName);
+	}
+
+
 	// **************** validation *********************************************
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMappedSuperclass.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMappedSuperclass.java
index bd30ea7c6b..cee2d7d566 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMappedSuperclass.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMappedSuperclass.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.Table;
 import org.eclipse.jpt.core.context.java.JavaIdClassReference;
@@ -24,7 +25,9 @@ import org.eclipse.jpt.core.internal.context.PrimaryKeyValidator;
 import org.eclipse.jpt.core.internal.jpa1.context.GenericMappedSuperclassPrimaryKeyValidator;
 import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
 import org.eclipse.jpt.core.resource.orm.XmlMappedSuperclass;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -126,7 +129,25 @@ public abstract class AbstractOrmMappedSuperclass extends AbstractOrmTypeMapping
 		super.update();
 		this.idClassReference.update(getJavaIdClassReferenceForDefaults());
 	}
-	
+
+
+	//************************* refactoring ************************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+					super.createReplaceTypeEdits(originalType, newName),
+					this.createIdClassReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createIdClassReplaceTypeEdits(IType originalType, String newName) {
+		return this.idClassReference.createReplaceEdits(originalType, newName);
+	}
+
+
+	// **************** validation *********************************************
+
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter) {
 		super.validate(messages, reporter);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
index e460f4a76a..0bcd8e0a63 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.BaseColumn;
 import org.eclipse.jpt.core.context.BaseOverride;
@@ -51,7 +52,11 @@ import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.db.Table;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -575,8 +580,33 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 	public String getMetamodelFieldMapKeyTypeName() {
 		return MappingTools.getMetamodelFieldMapKeyTypeName(this);
 	}
-	
-	
+
+
+	//************* refactoring *************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createReplaceTypeEdits(originalType, newName),
+			this.createMapKeyClassReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createMapKeyClassReplaceTypeEdits(IType originalType, String newName) {
+		if (this.specifiedMapKeyClass != null) {
+			String originalName = originalType.getFullyQualifiedName('.');
+			if (this.resolvedMapKeyType != null && this.resolvedMapKeyType.isFor(originalName)) {
+				return new SingleElementIterable<ReplaceEdit>(this.createReplaceMapKeyClassEdit(originalType, newName));
+			}
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceMapKeyClassEdit(IType originalType, String newName) {
+		return this.resourceAttributeMapping.createReplaceMapKeyClassEdit(originalType, newName);
+	}
+
+
 	// ********** validation **********
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
index fb0eab8ee7..5a5e0a982b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.AccessType;
@@ -27,6 +28,7 @@ import org.eclipse.jpt.core.jpa2.context.java.JavaPersistentAttribute2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmPersistentAttribute2_0;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -230,6 +232,13 @@ public abstract class AbstractOrmPersistentAttribute
 	}
 
 
+	// ********** refactoring **********
+
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return this.attributeMapping.createReplaceTypeEdits(originalType, newName);
+	}
+
+
 	// ********** validation **********
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmRelationshipMapping.java
index 975ffef534..7405344df8 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmRelationshipMapping.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
@@ -29,9 +30,13 @@ import org.eclipse.jpt.core.jpa2.context.orm.OrmCascade2_0;
 import org.eclipse.jpt.core.resource.orm.AbstractXmlRelationshipMapping;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -275,6 +280,34 @@ public abstract class AbstractOrmRelationshipMapping<T extends AbstractXmlRelati
 		return (this.resolvedTargetEntity == null) ? null : this.resolvedTargetEntity.getIdAttribute();
 	}
 
+
+	//************ refactoring ************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createReplaceTypeEdits(originalType, newName),
+			this.createTargetEntityReplaceTypeEdits(originalType, newName));
+	}
+	
+	protected Iterable<ReplaceEdit> createTargetEntityReplaceTypeEdits(IType originalType, String newName) {
+		if (this.specifiedTargetEntity != null) {
+			String originalName = originalType.getFullyQualifiedName('.');
+			if (this.resolvedTargetType != null && this.resolvedTargetType.isFor(originalName)) {
+				return new SingleElementIterable<ReplaceEdit>(this.createReplaceTargetEntityEdit(originalType, newName));
+			}
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceTargetEntityEdit(IType originalType, String newName) {
+		return this.resourceAttributeMapping.createReplaceTargetEntityEdit(originalType, newName);
+	}
+
+
+	//*********** validation ***********
+
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter) {
 		super.validate(messages, reporter);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
index c90b95eb1b..9583beda58 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.Column;
@@ -30,10 +31,13 @@ import org.eclipse.jpt.db.Schema;
 import org.eclipse.jpt.db.Table;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -359,11 +363,22 @@ public abstract class AbstractOrmTypeMapping<T extends XmlTypeMapping>
 
 
 	//************************* refactoring ************************
-	
+
 	public DeleteEdit createDeleteEdit() {
 		return this.resourceTypeMapping.createDeleteEdit();
 	}
 
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		if (getPersistentType().isFor(originalType.getFullyQualifiedName('.'))) {
+			return new SingleElementIterable<ReplaceEdit>(this.createReplaceTypeEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceTypeEdit(IType originalType, String newName) {
+		return this.resourceTypeMapping.createReplaceTypeEdit(originalType, newName);
+	}
+
 
 	// ********** misc **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdClassReference.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdClassReference.java
index 5b9a999399..a963f4c851 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdClassReference.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdClassReference.java
@@ -11,6 +11,7 @@
 package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.AccessType;
 import org.eclipse.jpt.core.context.java.JavaIdClassReference;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
@@ -25,6 +26,9 @@ import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlIdClassContainer;
 import org.eclipse.jpt.core.resource.orm.XmlTypeMapping;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -207,8 +211,29 @@ public class GenericOrmIdClassReference
 			}
 		}
 	}
-	
-	
+
+
+	//************************* refactoring ************************
+
+	public Iterable<ReplaceEdit> createReplaceEdits(IType originalType, String newName) {
+		if (this.isFor(originalType.getFullyQualifiedName('.'))) {
+			return new SingleElementIterable<ReplaceEdit>(this.createReplaceEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceEdit(IType originalType, String newName) {
+		return getIdXmlClassRef().createReplaceEdit(originalType, newName);
+	}
+
+	protected boolean isFor(String typeName) {
+		if (this.idClass != null && this.idClass.isFor(typeName)) {
+			return true;
+		}
+		return false;
+	}
+
+
 	// **************** validation ********************************************
 	
 	public TextRange getValidationTextRange() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
index 2d4c57ef2d..f2f7fb1598 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
@@ -293,6 +293,13 @@ public abstract class AbstractMappingFileRef
 		return EmptyIterable.instance();
 	}
 
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		if (this.mappingFile != null) {
+			return this.mappingFile.createReplaceTypeEdits(originalType, newName);
+		}
+		return EmptyIterable.instance();
+	}
+
 	public Iterable<ReplaceEdit> createReplaceMappingFileEdits(IFile originalFile, String newName) {
 		if (this.isFor(originalFile)) {
 			return new SingleElementIterable<ReplaceEdit>(this.createReplaceEdit(originalFile, newName));
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
index 06bade806f..701d717c28 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
@@ -137,8 +137,8 @@ public abstract class AbstractPersistenceUnit
 	protected boolean defaultDelimitedIdentifiers;
 
 	//****** PersistenceUnit2_0 features
-	private PersistenceUnitProperties connection;
-	private PersistenceUnitProperties options;
+	protected PersistenceUnitProperties connection;
+	protected PersistenceUnitProperties options;
 	
 	protected SharedCacheMode specifiedSharedCacheMode;
 	protected SharedCacheMode defaultSharedCacheMode;
@@ -967,6 +967,19 @@ public abstract class AbstractPersistenceUnit
 		return null;
 	}
 
+	public Iterable<Property> getPropertiesNamed(final String propertyName) {
+		if (propertyName == null) {
+			throw new NullPointerException();
+		}
+		return new FilteringIterable<Property>(CollectionTools.iterable(this.properties())) {
+			@Override
+			protected boolean accept(Property property) {
+				String pName = property.getName();
+				return (pName != null) && pName.equals(propertyName);
+			}
+		};
+	}
+
 	public Iterator<Property> propertiesWithNamePrefix(final String propertyNamePrefix) {
 		if (propertyNamePrefix == null) {
 			throw new NullPointerException();
@@ -1629,6 +1642,28 @@ public abstract class AbstractPersistenceUnit
 		);
 	}
 
+	@SuppressWarnings("unchecked")
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+					createSpecifiedClassRefReplaceTypeEdits(originalType, newName),
+					createPersistenceUnitPropertiesReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createSpecifiedClassRefReplaceTypeEdits(final IType originalType, final String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<ClassRef, Iterable<ReplaceEdit>>(getSpecifiedClassRefs()) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(ClassRef classRef) {
+					return classRef.createReplaceTypeEdits(originalType, newName);
+				}
+			}
+		);
+	}
+
+	protected Iterable<ReplaceEdit> createPersistenceUnitPropertiesReplaceTypeEdits(IType originalType, String newName) {
+		return this.options.createReplaceTypeEdits(originalType, newName);
+	}
+
 	public Iterable<ReplaceEdit> createReplaceMappingFileEdits(final IFile originalFile, final String newName) {
 		return new CompositeIterable<ReplaceEdit>(
 			new TransformationIterable<MappingFileRef, Iterable<ReplaceEdit>>(getMappingFileRefs()) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnitProperties.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnitProperties.java
index 0fe0ea4cd0..55b72fc134 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnitProperties.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnitProperties.java
@@ -14,13 +14,15 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.JpaProject;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnitProperties;
 import org.eclipse.jpt.utility.internal.ReflectionTools;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.utility.internal.model.AbstractModel;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  *  AbstractPersistenceUnitProperties
@@ -508,5 +510,11 @@ public abstract class AbstractPersistenceUnitProperties extends AbstractModel
 		sb.deleteCharAt(sb.length() - 1); 	// remove the last delimiter
 		return sb.toString();
 	}
-	
+
+
+	// ********** refactoring ************
+
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return EmptyIterable.instance();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmPersistentType.java
index 298a00ef07..3b031288b6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmPersistentType.java
@@ -61,6 +61,7 @@ import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
 import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.utility.internal.iterables.LiveCloneIterable;
 import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
+import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
 import org.eclipse.jpt.utility.internal.iterators.ChainIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
@@ -69,6 +70,7 @@ import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -946,6 +948,24 @@ public class GenericOrmPersistentType
 		return EmptyIterable.instance();
 	}
 
+	@SuppressWarnings("unchecked")
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			this.mapping.createReplaceTypeEdits(originalType, newName),
+			this.createSpecifiedAttributesReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createSpecifiedAttributesReplaceTypeEdits(final IType originalType, final String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<OrmPersistentAttribute, Iterable<ReplaceEdit>>(getSpecifiedAttributes()) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(OrmPersistentAttribute persistentAttribute) {
+					return persistentAttribute.createReplaceTypeEdits(originalType, newName);
+				}
+			}
+		);
+	}
+
 
 	// ********** misc **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmXml.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmXml.java
index 44877ab1d6..e498c9a100 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmXml.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmXml.java
@@ -27,6 +27,7 @@ import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -231,4 +232,11 @@ public class GenericOrmXml
 		}
 		return EmptyIterable.instance();
 	}
+
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		if (this.entityMappings != null) {
+			return this.entityMappings.createReplaceTypeEdits(originalType, newName);
+		}
+		return EmptyIterable.instance();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericClassRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericClassRef.java
index 6098fbfe47..320c37be47 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericClassRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericClassRef.java
@@ -31,6 +31,7 @@ import org.eclipse.jpt.utility.internal.Tools;
 import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.text.edits.DeleteEdit;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -320,6 +321,20 @@ public class GenericClassRef
 		return this.xmlJavaClassRef.createDeleteEdit();
 	}
 
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		if (isVirtual()) {
+			throw new IllegalStateException();
+		}
+		if (this.isFor(originalType)) {
+			return new SingleElementIterable<ReplaceEdit>(this.createReplaceEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceEdit(IType originalType, String newName) {
+		return this.xmlJavaClassRef.createReplaceEdit(originalType, newName);
+	}
+
 
 	// ********** misc **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericPersistenceUnitProperty.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericPersistenceUnitProperty.java
index b5f4aa822c..2c99c33281 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericPersistenceUnitProperty.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/persistence/GenericPersistenceUnitProperty.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2010 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.
@@ -9,10 +9,14 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa1.context.persistence;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.internal.context.persistence.AbstractPersistenceXmlContextNode;
 import org.eclipse.jpt.core.resource.persistence.XmlProperty;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * Straightforward implementation of the persistence unit property.
@@ -92,6 +96,20 @@ public class GenericPersistenceUnitProperty
 	}
 
 
+	// ********** refactoring **********
+
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		if (this.getValue() != null && this.getValue().equals(originalType.getFullyQualifiedName('.'))) {
+			return new SingleElementIterable<ReplaceEdit>(this.createReplaceTypeEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceTypeEdit(IType originalType, String newName) {
+		return this.xmlProperty.createReplaceTypeEdit(originalType, newName);
+	}
+
+
 	// ********** misc **********
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
index 00b1d5be03..5de731c1a7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.AssociationOverride;
 import org.eclipse.jpt.core.context.AttributeMapping;
@@ -69,9 +70,13 @@ import org.eclipse.jpt.db.Table;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.Transformer;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -1027,7 +1032,43 @@ public abstract class AbstractOrmElementCollectionMapping2_0<T extends XmlElemen
 	public String getMetamodelFieldMapKeyTypeName() {
 		return MappingTools.getMetamodelFieldMapKeyTypeName(this);
 	}
-	
+
+
+	//*********** refactoring ***********
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createReplaceTypeEdits(originalType, newName),
+			this.createMapKeyClassReplaceTypeEdits(originalType, newName),
+			this.createTargetClassReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createMapKeyClassReplaceTypeEdits(IType originalType, String newName) {
+		if (this.specifiedMapKeyClass != null) {
+			String originalName = originalType.getFullyQualifiedName('.');
+			if (this.resolvedMapKeyType != null && this.resolvedMapKeyType.isFor(originalName)) {
+				return new SingleElementIterable<ReplaceEdit>(this.createReplaceMapKeyClassEdit(originalType, newName));
+			}
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceMapKeyClassEdit(IType originalType, String newName) {
+		return this.resourceAttributeMapping.createReplaceMapKeyClassEdit(originalType, newName);
+	}
+
+	protected Iterable<ReplaceEdit> createTargetClassReplaceTypeEdits(IType originalType, String newName) {
+		if (this.specifiedTargetClass != null) {
+			String originalName = originalType.getFullyQualifiedName('.');
+			if (this.resolvedTargetType != null && this.resolvedTargetType.isFor(originalName)) {
+				return new SingleElementIterable<ReplaceEdit>(this.resourceAttributeMapping.createReplaceTargetClassEdit(originalType, newName));
+			}
+		}
+		return EmptyIterable.instance();
+	}
+
 
 	// ********** validation **********
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaCoreRefactoringMessages.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaCoreRefactoringMessages.java
index 0df873e22c..409b259542 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaCoreRefactoringMessages.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaCoreRefactoringMessages.java
@@ -30,6 +30,13 @@ public class JpaCoreRefactoringMessages {
 	
 	public static String JPA_REFACORING_PARTICIPANT_LOADING_JPA_PROJECTS_SUB_TASK_NAME;
 
+	public static String JPA_RENAME_TYPE_REFACTORING_PARTICIPANT_NAME;
+	public static String JPA_RENAME_PACKAGE_REFACTORING_PARTICIPANT_NAME;
+	public static String JPA_RENAME_TYPE_REFACTORING_CHANGE_NAME;
+	public static String JPA_RENAME_TYPE_REFACTORING_CHANGE_PERSISTENCE_XML_NAME;
+	public static String JPA_RENAME_TYPE_REFACTORING_CHANGE_MAPPING_FILE_NAME;
+	public static String JPA_RENAME_TYPE_REFACTORING_SUB_TASK_NAME;
+
 	public static String JPA_RENAME_MAPPING_FILE_REFACTORING_PARTICIPANT_NAME;
 	public static String JPA_RENAME_MAPPING_FILE_REFACTORING_SUB_TASK_NAME;
 	public static String JPA_RENAME_MAPPING_FILE_REFACTORING_CHANGE_NAME;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaRenameTypeParticipant.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaRenameTypeParticipant.java
new file mode 100644
index 0000000000..fd70cc5ee6
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/refactoring/JpaRenameTypeParticipant.java
@@ -0,0 +1,333 @@
+/*******************************************************************************
+ * Copyright (c) 2010 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.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.refactoring;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jpt.core.JpaProject;
+import org.eclipse.jpt.core.JpaProjectManager;
+import org.eclipse.jpt.core.JptCorePlugin;
+import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.context.persistence.Persistence;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
+import org.eclipse.jpt.core.context.persistence.PersistenceXml;
+import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
+import org.eclipse.ltk.core.refactoring.Change;
+import org.eclipse.ltk.core.refactoring.CompositeChange;
+import org.eclipse.ltk.core.refactoring.RefactoringStatus;
+import org.eclipse.ltk.core.refactoring.TextChange;
+import org.eclipse.ltk.core.refactoring.TextFileChange;
+import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext;
+import org.eclipse.ltk.core.refactoring.participants.RenameParticipant;
+import org.eclipse.ltk.core.refactoring.participants.ResourceChangeChecker;
+import org.eclipse.text.edits.MalformedTreeException;
+import org.eclipse.text.edits.MultiTextEdit;
+import org.eclipse.text.edits.ReplaceEdit;
+import org.eclipse.text.edits.TextEdit;
+
+//TODO RenameTypeArguments.updateSimilarDeclarations() - http://www.eclipse.org/jdt/ui/r3_2/RenameType.html
+public class JpaRenameTypeParticipant
+	extends RenameParticipant {
+
+	protected IType originalType;
+	
+	protected final Collection<IType> nestedTypes;
+
+	/**
+	 * Store the persistence.xml ReplaceEdits in the checkConditions() call 
+	 * to avoid duplicated effort in createChange().
+	 */
+	protected final Map<IFile, Iterable<ReplaceEdit>> persistenceXmlClassRefReplaceEdits;
+
+	/**
+	 * Store the mapping file ReplaceEdits in the checkConditions() call 
+	 * to avoid duplicated effort in createChange().
+	 */
+	protected final Map<IFile, Iterable<ReplaceEdit>> mappingFilePersistentTypeReplaceEdits;
+
+	public JpaRenameTypeParticipant() {
+		super();
+		this.nestedTypes = new ArrayList<IType>();
+		this.persistenceXmlClassRefReplaceEdits = new HashMap<IFile, Iterable<ReplaceEdit>>();
+		this.mappingFilePersistentTypeReplaceEdits = new HashMap<IFile, Iterable<ReplaceEdit>>();
+	}
+
+	@Override
+	public String getName() {
+		return JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_PARTICIPANT_NAME;
+	}
+
+	@Override
+	protected boolean initialize(Object element) {
+		if (!getArguments().getUpdateReferences()) {
+			//we do not want to do any refactoring if the user chooses not to update references
+			return false;
+		}
+		this.originalType = (IType) element;
+		this.addNestedTypes(this.originalType);
+		return true;
+	}
+
+	protected void addNestedType(IType renamedType) {
+		this.nestedTypes.add(renamedType);
+		this.addNestedTypes(renamedType);
+	}
+
+	private void addNestedTypes(IType renamedType) {
+		IType[] nestedTypes;
+		try {
+			nestedTypes = renamedType.getTypes();
+		}
+		catch (JavaModelException ex) {
+			JptCorePlugin.log(ex);
+			return;
+		}
+
+		for (IType nestedType : nestedTypes) {
+			this.addNestedType(nestedType);
+		}
+	}
+
+
+	//**************** RefactoringParticipant implementation *****************
+
+	/**
+	 * Inform the refactoring processor of any files that are going to change. In the process of determining
+	 * this go ahead and build up the appropriate ReplaceEdits to be used in the createChange()
+	 */
+	@Override
+	public RefactoringStatus checkConditions(IProgressMonitor monitor, CheckConditionsContext context) throws OperationCanceledException {
+		monitor.subTask(JpaCoreRefactoringMessages.JPA_REFACORING_PARTICIPANT_LOADING_JPA_PROJECTS_SUB_TASK_NAME);
+		JpaProjectManager jpaProjectManager = JptCorePlugin.getJpaProjectManager();
+		if (jpaProjectManager.getJpaProjectsSize() == 0) {
+			return null;
+		}
+		SubMonitor sm = SubMonitor.convert(monitor, jpaProjectManager.getJpaProjectsSize()*10 + 2);
+		sm.subTask(this.getCheckConditionsSubTaskName());
+		ResourceChangeChecker checker = (ResourceChangeChecker) context.getChecker(ResourceChangeChecker.class);
+		IResourceChangeDescriptionFactory deltaFactory = checker.getDeltaFactory();
+
+		for (JpaProject jpaProject : jpaProjectManager.getJpaProjects()) {
+			this.createReplaceEdits(sm.newChild(10), jpaProject);
+		}
+		if (sm.isCanceled()) {
+			throw new OperationCanceledException();
+		}
+		for (IFile file : this.persistenceXmlClassRefReplaceEdits.keySet()) {
+			deltaFactory.change(file);
+		}
+		sm.worked(1);
+		for (IFile file : this.mappingFilePersistentTypeReplaceEdits.keySet()) {
+			deltaFactory.change(file);
+		}
+		sm.worked(1);
+		
+		return null;
+	}
+
+	/**
+	 * This will be appended to the main refactoring task named : 'Checking preconditions...'
+	 */
+	protected String getCheckConditionsSubTaskName() {
+		return JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_SUB_TASK_NAME;
+	}
+
+	@Override
+	public Change createChange(IProgressMonitor monitor) throws CoreException, OperationCanceledException {
+		if (this.persistenceXmlClassRefReplaceEdits.isEmpty() && this.mappingFilePersistentTypeReplaceEdits.isEmpty()) {
+			return null;
+		}
+		SubMonitor sm = SubMonitor.convert(monitor, this.persistenceXmlClassRefReplaceEdits.size() + this.mappingFilePersistentTypeReplaceEdits.size());
+		sm.subTask(this.getCreateChangeSubTaskName());
+		CompositeChange compositeChange = new CompositeChange(JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_CHANGE_NAME);
+		for (IFile persistenceXmlFile : this.persistenceXmlClassRefReplaceEdits.keySet()) {
+			this.addPersistenceXmlRenameTypeChange(persistenceXmlFile, compositeChange);
+			sm.worked(1);
+		}
+		for (IFile mappingFile : this.mappingFilePersistentTypeReplaceEdits.keySet()) {
+			if (sm.isCanceled()) {
+				throw new OperationCanceledException();
+			}
+			this.addMappingFileRenameTypeChange(mappingFile, compositeChange);
+			sm.worked(1);
+		}
+		//must check for children in case all changes were made in other participant's TextChanges, 
+		//want to return null so our node does not appear in the preview tree
+		return compositeChange.getChildren().length == 0 ? null : compositeChange;
+	}
+
+	/**
+	 * This will be appended to the main refactoring task named : 'Creating workspace modifications...'
+	 */
+	protected String getCreateChangeSubTaskName() {
+		return JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_SUB_TASK_NAME;
+	}
+
+	protected void createReplaceEdits(IProgressMonitor monitor, JpaProject jpaProject) throws OperationCanceledException {
+		PersistenceUnit persistenceUnit = getPersistenceUnit(jpaProject);
+		if (persistenceUnit == null) {
+			return;
+		}
+		SubMonitor sm = SubMonitor.convert(monitor, 1 + persistenceUnit.mappingFileRefsSize());
+		Iterable<ReplaceEdit> classRefDeleteEdits = this.createPersistenceXmlReplaceTypeEdits(persistenceUnit);
+		sm.worked(1);
+		if (!CollectionTools.isEmpty(classRefDeleteEdits)) {
+			this.persistenceXmlClassRefReplaceEdits.put(jpaProject.getPersistenceXmlResource().getFile(), classRefDeleteEdits);
+		}
+		for (MappingFileRef mappingFileRef : CollectionTools.iterable(persistenceUnit.mappingFileRefs())) {
+			if (sm.isCanceled()) {
+				throw new OperationCanceledException();
+			}
+			Iterable<ReplaceEdit> mappingFileReplaceEdits = this.createMappingFileReplaceTypeEdits(mappingFileRef);
+			if (!CollectionTools.isEmpty(mappingFileReplaceEdits)) {
+				IFile file = (IFile) mappingFileRef.getMappingFile().getResource();
+				this.mappingFilePersistentTypeReplaceEdits.put(file, mappingFileReplaceEdits);
+			}
+			sm.worked(1);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private Iterable<ReplaceEdit> createPersistenceXmlReplaceTypeEdits(PersistenceUnit persistenceUnit) {		
+		//check isOnClassPath since there could be types with the same name in different projects
+		if (persistenceUnit.getJpaProject().getJavaProject().isOnClasspath(this.originalType)) {
+			return new CompositeIterable<ReplaceEdit>(
+				this.createPersistenceXmlReplaceOriginalTypeEdits(persistenceUnit),
+				this.createPersistenceXmlReplaceNestedTypeEdits(persistenceUnit));
+		}
+		return EmptyIterable.instance();
+	}
+
+	private Iterable<ReplaceEdit> createPersistenceXmlReplaceOriginalTypeEdits(PersistenceUnit persistenceUnit) {
+		return persistenceUnit.createReplaceTypeEdits(this.originalType, this.getNewName());
+	}
+
+	private Iterable<ReplaceEdit> createPersistenceXmlReplaceNestedTypeEdits(final PersistenceUnit persistenceUnit) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<IType, Iterable<ReplaceEdit>>(this.nestedTypes) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(IType nestedType) {
+					String newName = getNewNameForNestedType(nestedType);
+					return persistenceUnit.createReplaceTypeEdits(nestedType, newName);
+				}
+			}
+		);
+	}
+
+	protected String getNewName() {
+		String newName = getArguments().getNewName();
+		try {
+			if (this.originalType.isMember()) {
+				newName = this.originalType.getTypeQualifiedName().substring(0, this.originalType.getTypeQualifiedName().lastIndexOf('$')) + '$' + newName;
+			}
+		}
+		catch (JavaModelException e) {
+			JptCorePlugin.log(e);
+		}
+		return newName;
+	}
+
+	protected String getNewNameForNestedType(IType nestedType) {
+		return nestedType.getTypeQualifiedName('$').replaceFirst(this.originalType.getElementName(), getArguments().getNewName());
+	}
+
+	protected void addPersistenceXmlRenameTypeChange(IFile persistenceXmlFile, CompositeChange compositeChange) {
+		Iterable<ReplaceEdit> replaceTypeEdits = this.persistenceXmlClassRefReplaceEdits.get(persistenceXmlFile);
+
+		TextChange textChange = getTextChange(persistenceXmlFile);
+		if (textChange == null) {
+			textChange = new TextFileChange(JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_CHANGE_PERSISTENCE_XML_NAME, persistenceXmlFile);
+			//TODO probably need to figure out TextEditGroups since these can be used to show check boxes under the file in the preview dialog
+			//also used to add edits to existing changes??
+			MultiTextEdit multiTextEdit = new MultiTextEdit();
+			textChange.setEdit(multiTextEdit);
+//			textChange.addTextEditGroup(new TextEditGroup("edit persistence unit", multiTextEdit));???
+			compositeChange.add(textChange);
+		}
+		this.addEdits(textChange, replaceTypeEdits);
+	}
+
+	@SuppressWarnings("unchecked")
+	private Iterable<ReplaceEdit> createMappingFileReplaceTypeEdits(MappingFileRef mappingFileRef) {		
+		//check isOnClassPath since there could be types with the same name in different projects
+		if (mappingFileRef.getJpaProject().getJavaProject().isOnClasspath(this.originalType)) {
+			return new CompositeIterable<ReplaceEdit>(
+				this.createMappingFileReplaceOriginalTypeEdits(mappingFileRef),
+				this.createMappingFileReplaceNestedTypeEdits(mappingFileRef));
+		}
+		return EmptyIterable.instance();
+	}
+
+	private Iterable<ReplaceEdit> createMappingFileReplaceOriginalTypeEdits(MappingFileRef mappingFileRef) {
+		return mappingFileRef.createReplaceTypeEdits(this.originalType, this.getNewName());
+	}
+
+	private Iterable<ReplaceEdit> createMappingFileReplaceNestedTypeEdits(final MappingFileRef mappingFileRef) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<IType, Iterable<ReplaceEdit>>(this.nestedTypes) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(IType nestedType) {
+					String newName = getNewNameForNestedType(nestedType);
+					return mappingFileRef.createReplaceTypeEdits(nestedType, newName);
+				}
+			}
+		);
+	}
+
+	protected void addMappingFileRenameTypeChange(IFile mappingFile, CompositeChange compositeChange) {
+		Iterable<ReplaceEdit> replacedTypeEdits = this.mappingFilePersistentTypeReplaceEdits.get(mappingFile);
+
+		TextChange textChange = getTextChange(mappingFile);
+		if (textChange == null) {
+			textChange = new TextFileChange(JpaCoreRefactoringMessages.JPA_RENAME_TYPE_REFACTORING_CHANGE_MAPPING_FILE_NAME, mappingFile);
+			MultiTextEdit multiTextEdit = new MultiTextEdit();
+			textChange.setEdit(multiTextEdit);
+			compositeChange.add(textChange);
+		}
+		this.addEdits(textChange, replacedTypeEdits);
+	}
+
+	private PersistenceUnit getPersistenceUnit(JpaProject jpaProject) {
+		PersistenceXml persistenceXml = jpaProject.getRootContextNode().getPersistenceXml();
+		Persistence persistence = persistenceXml.getPersistence();
+		if (persistence == null) {
+			return null;
+		}
+		if (persistence.persistenceUnitsSize() != 1) {
+			return null;  // the context model currently only supports 1 persistence unit
+		}
+		return persistence.persistenceUnits().next();		
+	}
+
+	private void addEdits(TextChange textChange, Iterable<? extends TextEdit> textEdits) {
+		for (TextEdit textEdit : textEdits) {
+			try {
+				textChange.addEdit(textEdit);
+			}
+			catch (MalformedTreeException ex) {
+				//log exception and don't add this persistence.xml type deletion to the conflicting change object
+				JptCorePlugin.log(ex);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlMultiRelationshipMapping.java
index 5444fc9c44..2ab9a3427e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlMultiRelationshipMapping.java
@@ -18,12 +18,14 @@ 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.IType;
 import org.eclipse.jpt.core.resource.orm.v2_0.JPA2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.OrmV2_0Package;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlMapKeyAttributeOverrideContainer_2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlMultiRelationshipMapping_2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlOrderable_2_0;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 
@@ -1083,4 +1085,12 @@ public abstract class AbstractXmlMultiRelationshipMapping extends AbstractXmlRel
 	protected static Translator buildOrderColumnTranslator() {
 		return XmlOrderColumn.buildTranslator(JPA2_0.ORDER_COLUMN, OrmV2_0Package.eINSTANCE.getXmlOrderable_2_0_OrderColumn());
 	}
+
+
+	// ********** refactoring **********
+
+	public ReplaceEdit createReplaceMapKeyClassEdit(IType originalType, String newName) {
+		return getMapKeyClass().createReplaceEdit(originalType, newName);
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlRelationshipMapping.java
index 2f590a2bf7..f23098cd78 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlRelationshipMapping.java
@@ -14,7 +14,9 @@ import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 
@@ -378,5 +380,15 @@ public abstract class AbstractXmlRelationshipMapping extends AbstractXmlAttribut
 	protected static Translator buildCascadeTranslator() {
 		return CascadeType.buildTranslator(JPA.CASCADE, OrmPackage.eINSTANCE.getAbstractXmlRelationshipMapping_Cascade());
 	}
-	
+
+
+	// ********** refactoring **********
+
+	public ReplaceEdit createReplaceTargetEntityEdit(IType originalType, String newName) {
+		String originalName = originalType.getElementName();
+		int nameIndex = this.targetEntity.lastIndexOf(originalName);
+		int offset = getAttributeNode(JPA.TARGET_ENTITY).getValueRegionStartOffset() + 1;
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
+
 } // RelationshipMapping
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlTypeMapping.java
index 322b3eab36..66e8fe17c5 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlTypeMapping.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2010 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.
@@ -14,8 +14,10 @@ import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.resource.xml.AbstractJpaEObject;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 /**
@@ -516,6 +518,16 @@ public abstract class AbstractXmlTypeMapping extends AbstractJpaEObject implemen
 	
 	protected static Translator buildAttributesTranslator() {
 		return Attributes.buildTranslator();
-	}	
+	}
+
+
+	// ********** refactoring **********
+
+	public ReplaceEdit createReplaceTypeEdit(IType originalType, String newName) {
+		String originalName = originalType.getTypeQualifiedName();
+		int nameIndex = this.className.lastIndexOf(originalName);
+		int offset = getAttributeNode(JPA.CLASS).getValueRegionStartOffset() + 1; // +1 = opening double quote
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
 
 } // TypeMapping
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlClassReference.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlClassReference.java
index 26cad878dc..edde3bc7e0 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlClassReference.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlClassReference.java
@@ -15,10 +15,12 @@ import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.internal.utility.translators.SimpleTranslator;
 import org.eclipse.jpt.core.resource.xml.AbstractJpaEObject;
 import org.eclipse.jpt.core.resource.xml.JpaEObject;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 /**
@@ -226,4 +228,12 @@ public class XmlClassReference extends AbstractJpaEObject implements JpaEObject
 	private static Translator buildClassTranslator() {
 		return new Translator(JPA.CLASS, OrmPackage.eINSTANCE.getXmlClassReference_ClassName(), Translator.DOM_ATTRIBUTE);
 	}
+
+	public ReplaceEdit createReplaceEdit(IType originalType, String newName) {
+		String originalName = originalType.getElementName();
+		int nameIndex = this.className.lastIndexOf(originalName);
+
+		int offset = getAttributeNode(JPA.CLASS).getValueRegionStartOffset() + 1;
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlElementCollection.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlElementCollection.java
index 3103bc7640..9b4ef50ba3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlElementCollection.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlElementCollection.java
@@ -21,7 +21,7 @@ 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.jpt.core.internal.utility.translators.BooleanTranslator;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.internal.utility.translators.EmptyTagBooleanTranslator;
 import org.eclipse.jpt.core.internal.utility.translators.SimpleTranslator;
 import org.eclipse.jpt.core.jpa2.MappingKeys2_0;
@@ -31,6 +31,7 @@ import org.eclipse.jpt.core.resource.orm.v2_0.XmlElementCollection_2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlMapKeyAttributeOverrideContainer_2_0;
 import org.eclipse.jpt.core.resource.orm.v2_0.XmlOrderable_2_0;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 /**
@@ -1631,4 +1632,19 @@ public class XmlElementCollection extends AbstractXmlAttributeMapping implements
 	protected static Translator buildMapKeyAttributeOverrideTranslator() {
 		return XmlAttributeOverride.buildTranslator(JPA2_0.MAP_KEY_ATTRIBUTE_OVERRIDE, OrmV2_0Package.eINSTANCE.getXmlMapKeyAttributeOverrideContainer_2_0_MapKeyAttributeOverrides());
 	}
+
+
+	// ********** refactoring **********
+
+	public ReplaceEdit createReplaceTargetClassEdit(IType originalType, String newName) {
+		String originalName = originalType.getElementName();
+		int nameIndex = this.targetClass.lastIndexOf(originalName);
+		int offset = getAttributeNode(JPA2_0.TARGET_CLASS).getValueRegionStartOffset() + 1;
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
+
+	public ReplaceEdit createReplaceMapKeyClassEdit(IType originalType, String newName) {
+		return getMapKeyClass().createReplaceEdit(originalType, newName);
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlTypeMapping.java
index e8a71a6ccc..18a6dc13a1 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/XmlTypeMapping.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009 Oracle. All rights reserved.
+ * Copyright (c) 2009, 2010 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.
@@ -9,7 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.resource.orm;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  * <!-- begin-user-doc -->
@@ -149,4 +151,9 @@ public interface XmlTypeMapping extends XmlAccessHolder
 
 	//TODO not happy with this, or the corresponding one in XmlAttributeMapping
 	String getMappingKey();
+
+
+	// ********** refactoring **********
+
+	ReplaceEdit createReplaceTypeEdit(IType originalType, String newName);
 } // XmlTypeMapping
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlJavaClassRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlJavaClassRef.java
index 807ed320c7..c9e02be73b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlJavaClassRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlJavaClassRef.java
@@ -14,9 +14,10 @@ import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.internal.utility.translators.SimpleTranslator;
 import org.eclipse.jpt.core.resource.xml.AbstractJpaEObject;
-import org.eclipse.jpt.core.resource.xml.JpaEObject;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
 
 /**
@@ -42,7 +43,7 @@ import org.eclipse.wst.common.internal.emf.resource.Translator;
  * @extends JpaEObject
  * @generated
  */
-public class XmlJavaClassRef extends AbstractJpaEObject implements JpaEObject
+public class XmlJavaClassRef extends AbstractJpaEObject
 {
 	/**
 	 * The default value of the '{@link #getJavaClass() <em>Java Class</em>}' attribute.
@@ -228,4 +229,14 @@ public class XmlJavaClassRef extends AbstractJpaEObject implements JpaEObject
 				PersistencePackage.eINSTANCE.getXmlJavaClassRef_JavaClass()
 			);
 	}
+
+
+	// *********** refactoring ***********
+
+	public ReplaceEdit createReplaceEdit(IType originalType, String newName) {
+		String originalName = originalType.getTypeQualifiedName();
+		int nameIndex = this.javaClass.lastIndexOf(originalName);
+		int offset = getTextNode().getStartOffset();
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlProperty.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlProperty.java
index 22e944c680..30d38b310b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlProperty.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/persistence/XmlProperty.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2009 Oracle. All rights reserved.
+ * Copyright (c) 2006, 2010 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.
@@ -14,10 +14,13 @@ import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.internal.utility.translators.SimpleTranslator;
 import org.eclipse.jpt.core.resource.xml.AbstractJpaEObject;
 import org.eclipse.jpt.core.resource.xml.JpaEObject;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.common.internal.emf.resource.Translator;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMAttr;
 
 /**
  * <!-- begin-user-doc -->
@@ -302,4 +305,16 @@ public class XmlProperty extends AbstractJpaEObject implements JpaEObject
 			);
 	}
 
+	public ReplaceEdit createReplaceTypeEdit(IType originalType, String newName) {
+		IDOMAttr domAttr = getAttributeNode(JPA.PROPERTY__VALUE);
+		if (domAttr == null) {
+			return null;
+		}
+		String originalName = originalType.getElementName();
+		int nameIndex = originalType.getFullyQualifiedName('.').lastIndexOf(originalName);
+
+		int offset = domAttr.getValueRegionStartOffset() + 1;
+		return new ReplaceEdit(offset + nameIndex, originalName.length(), newName);
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/META-INF/MANIFEST.MF b/jpa/plugins/org.eclipse.jpt.eclipselink.core/META-INF/MANIFEST.MF
index c943f1799b..043f10f2b0 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/META-INF/MANIFEST.MF
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/META-INF/MANIFEST.MF
@@ -26,7 +26,8 @@ Require-Bundle: org.eclipse.core.commands;bundle-version="[3.4.0,4.0.0)",
  org.eclipse.wst.common.emfworkbench.integration;bundle-version="[1.1.200,2.0.0)",
  org.eclipse.wst.common.frameworks;bundle-version="[1.1.200,2.0.0)",
  org.eclipse.wst.common.modulecore;bundle-version="[1.1.200,2.0.0)",
- org.eclipse.wst.validation;bundle-version="[1.2.0,2.0.0)"
+ org.eclipse.wst.validation;bundle-version="[1.2.0,2.0.0)",
+ org.eclipse.wst.xml.core;bundle-version="[1.1.300,2.0.0)"
 Export-Package: org.eclipse.jpt.eclipselink.core,
  org.eclipse.jpt.eclipselink.core.context,
  org.eclipse.jpt.eclipselink.core.context.java,
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCustomizer.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCustomizer.java
index 401c821822..d36642f217 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCustomizer.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkCustomizer.java
@@ -9,14 +9,20 @@
  ******************************************************************************/
 package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jpt.core.context.orm.EntityMappings;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmXmlContextNode;
+import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkCustomizer;
 import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkCustomizer;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCustomizerHolder;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 
 public class OrmEclipseLinkCustomizer extends AbstractOrmXmlContextNode
 	implements EclipseLinkCustomizer
@@ -27,13 +33,19 @@ public class OrmEclipseLinkCustomizer extends AbstractOrmXmlContextNode
 	
 	protected String defaultCustomizerClass;
 	
+	protected JavaResourcePersistentType customizerPersistentType;
+
 	public OrmEclipseLinkCustomizer(OrmTypeMapping parent, XmlCustomizerHolder resource, JavaEclipseLinkCustomizer javaCustomizer) {
 		super(parent);
 		this.resource = resource;
 		this.defaultCustomizerClass = getJavaCustomizerClass(javaCustomizer);
 		this.specifiedCustomizerClass = getResourceCustomizerClass();
+		this.customizerPersistentType = getResourceCustomizerPersistentType();
 	}
+
 	
+	// **************** EclipseLinkCustomizer impl *********************************
+
 	public char getCustomizerClassEnclosingTypeSeparator() {
 		return '$';
 	}
@@ -79,6 +91,24 @@ public class OrmEclipseLinkCustomizer extends AbstractOrmXmlContextNode
 		this.specifiedCustomizerClass = newCustomizerClass;
 		firePropertyChanged(SPECIFIED_CUSTOMIZER_CLASS_PROPERTY, oldCustomizerClass, newCustomizerClass);
 	}
+
+	protected JavaResourcePersistentType getResourceCustomizerPersistentType() {
+		XmlClassReference customizerClassRef = this.getResourceCustomizer();
+		if (customizerClassRef == null) {
+			return null;
+		}
+
+		String className = customizerClassRef.getClassName();
+		if (className == null) {
+			return null;
+		}
+
+		return this.getEntityMappings().resolveJavaResourcePersistentType(className);
+	}
+
+	protected EntityMappings getEntityMappings() {
+		return (EntityMappings) getMappingFileRoot();
+	}
 	
 	protected XmlClassReference getResourceCustomizer() {
 		return this.resource.getCustomizer();
@@ -98,6 +128,7 @@ public class OrmEclipseLinkCustomizer extends AbstractOrmXmlContextNode
 	protected void update(JavaEclipseLinkCustomizer javaCustomizer) {
 		setDefaultCustomizerClass(getJavaCustomizerClass(javaCustomizer));
 		setSpecifiedCustomizerClass_(getResourceCustomizerClass());
+		updateCustomizerPersistentType();
 	}
 	
 	protected String getJavaCustomizerClass(JavaEclipseLinkCustomizer javaCustomizer) {
@@ -109,7 +140,32 @@ public class OrmEclipseLinkCustomizer extends AbstractOrmXmlContextNode
 		return (resource == null) ? null : resource.getClassName();
 	}
 	
-	
+	protected void updateCustomizerPersistentType() {
+		this.customizerPersistentType = this.getResourceCustomizerPersistentType();
+	}
+
+
+	//************************* refactoring ************************
+
+	public Iterable<ReplaceEdit> createReplaceEdits(IType originalType, String newName) {
+		if (this.isFor(originalType.getFullyQualifiedName('.'))) {
+			return new SingleElementIterable<ReplaceEdit>(this.createReplaceEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected ReplaceEdit createReplaceEdit(IType originalType, String newName) {
+		return getResourceCustomizer().createReplaceEdit(originalType, newName);
+	}
+
+	protected boolean isFor(String typeName) {
+		if (this.customizerPersistentType != null && this.customizerPersistentType.getQualifiedName().equals(typeName)) {
+			return true;
+		}
+		return false;
+	}
+
+
 	// **************** validation **************************************
 	
 	public TextRange getValidationTextRange() {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEmbeddableImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEmbeddableImpl.java
index 9abd0ce78d..2c35e4d7a1 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEmbeddableImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEmbeddableImpl.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmEmbeddable;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkChangeTracking;
@@ -22,6 +23,8 @@ import org.eclipse.jpt.eclipselink.core.resource.orm.XmlChangeTrackingHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlConvertersHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCustomizerHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlEmbeddable;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -92,8 +95,23 @@ public class OrmEclipseLinkEmbeddableImpl
 		JavaEclipseLinkEmbeddable javaEmbeddable = getJavaEmbeddableForDefaults();
 		return (javaEmbeddable == null) ? null : javaEmbeddable.getChangeTracking();
 	}
-	
-	
+
+
+	//************************* refactoring ************************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createReplaceTypeEdits(originalType, newName),
+			this.createCustomizerReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createCustomizerReplaceTypeEdits(IType originalType, String newName) {
+		return this.customizer.createReplaceEdits(originalType, newName);
+	}
+
+
 	// **************** validation **************************************
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
index 84a911a1ee..cbd35cc5e3 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkEntityImpl.java
@@ -10,6 +10,8 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 
 import java.util.List;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jpt.core.context.orm.EntityMappings;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.PrimaryKeyValidator;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmEntity;
@@ -36,6 +38,10 @@ import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCustomizerHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlEntity;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlReadOnly;
 import org.eclipse.jpt.eclipselink.core.v2_0.resource.java.EclipseLinkClassExtractorAnnotation2_1;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.SingleElementIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -53,6 +59,7 @@ public class OrmEclipseLinkEntityImpl
 	
 	protected final OrmEclipseLinkConverterHolder converterHolder;
 	
+	protected JavaResourcePersistentType classExtractorPersistentType;
 	
 	public OrmEclipseLinkEntityImpl(OrmPersistentType parent, XmlEntity resourceMapping) {
 		super(parent, resourceMapping);
@@ -61,6 +68,7 @@ public class OrmEclipseLinkEntityImpl
 		this.changeTracking = new OrmEclipseLinkChangeTracking(this, (XmlChangeTrackingHolder) this.resourceTypeMapping, getJavaChangeTracking());
 		this.caching = new OrmEclipseLinkCachingImpl(this, (XmlCacheHolder) this.resourceTypeMapping, (XmlCacheable_2_0) this.resourceTypeMapping, getJavaCaching());
 		this.converterHolder = new OrmEclipseLinkConverterHolder(this, (XmlConvertersHolder) this.resourceTypeMapping);
+		this.classExtractorPersistentType = getResourceClassExtractorPersistentType();
 	}
 	
 	
@@ -124,6 +132,25 @@ public class OrmEclipseLinkEntityImpl
 		return null;
 	}
 
+	protected JavaResourcePersistentType getResourceClassExtractorPersistentType() {
+		XmlClassReference classExtractorClassRef = this.getResourceClassExtractor();
+		if (classExtractorClassRef == null) {
+			return null;
+		}
+
+		String className = classExtractorClassRef.getClassName();
+		if (className == null) {
+			return null;
+		}
+
+		return this.getEntityMappings().resolveJavaResourcePersistentType(className);
+	}
+
+	protected EntityMappings getEntityMappings() {
+		return (EntityMappings) getMappingFileRoot();
+	}
+
+
 	// **************** resource-context interaction ***************************
 	
 	@Override
@@ -134,6 +161,7 @@ public class OrmEclipseLinkEntityImpl
 		this.changeTracking.update(getJavaChangeTracking());
 		this.caching.update(getJavaCaching());
 		this.converterHolder.update(); 
+		this.updateClassExtractorPersistentType();
 	}
 	
 	@Override
@@ -166,7 +194,41 @@ public class OrmEclipseLinkEntityImpl
 		return (javaEntity == null) ? false : javaEntity.usesPrimaryKeyColumns();
 	}
 	
-	
+	protected void updateClassExtractorPersistentType() {
+		this.classExtractorPersistentType = this.getResourceClassExtractorPersistentType();
+	}
+
+
+	//************************* refactoring ************************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+					super.createReplaceTypeEdits(originalType, newName),
+					this.createCustomizerReplaceTypeEdits(originalType, newName),
+					this.createClassExtractorReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createCustomizerReplaceTypeEdits(IType originalType, String newName) {
+		return this.customizer.createReplaceEdits(originalType, newName);
+	}
+
+	protected Iterable<ReplaceEdit> createClassExtractorReplaceTypeEdits(IType originalType, String newName) {
+		if (this.classExtractorIsFor(originalType.getFullyQualifiedName('.'))) {
+			return new SingleElementIterable<ReplaceEdit>(this.getResourceClassExtractor().createReplaceEdit(originalType, newName));
+		}
+		return EmptyIterable.instance();
+	}
+
+	protected boolean classExtractorIsFor(String typeName) {
+		if (this.classExtractorPersistentType != null && this.classExtractorPersistentType.getQualifiedName().equals(typeName)) {
+			return true;
+		}
+		return false;
+	}
+
+
 	// **************** validation **************************************
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
index d90b9b5976..6422c3b67a 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/orm/OrmEclipseLinkMappedSuperclassImpl.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.orm;
 
 import java.util.List;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.internal.context.PrimaryKeyValidator;
 import org.eclipse.jpt.core.internal.context.orm.AbstractOrmMappedSuperclass;
@@ -32,6 +33,8 @@ import org.eclipse.jpt.eclipselink.core.resource.orm.XmlConvertersHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlCustomizerHolder;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlMappedSuperclass;
 import org.eclipse.jpt.eclipselink.core.resource.orm.XmlReadOnly;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -140,8 +143,23 @@ public class OrmEclipseLinkMappedSuperclassImpl
 		return (javaMappedSuperclass == null) ? false : javaMappedSuperclass.usesPrimaryKeyColumns();
 	}
 	
-	
-	// **************** validation **************************************
+
+	//************************* refactoring ************************
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createReplaceTypeEdits(originalType, newName),
+			this.createCustomizerReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createCustomizerReplaceTypeEdits(IType originalType, String newName) {
+		return this.customizer.createReplaceEdits(originalType, newName);
+	}
+
+
+	// *********** validation ************
 	
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter) {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/EclipseLinkPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/EclipseLinkPersistenceUnit.java
index bf467fc3fd..a6eafbbe53 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/EclipseLinkPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/EclipseLinkPersistenceUnit.java
@@ -16,6 +16,7 @@ import java.util.List;
 import java.util.ListIterator;
 import java.util.Set;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
 import org.eclipse.jpt.core.context.persistence.Persistence;
 import org.eclipse.jpt.core.internal.context.persistence.AbstractPersistenceUnit;
@@ -40,12 +41,14 @@ import org.eclipse.jpt.eclipselink.core.internal.context.persistence.customizati
 import org.eclipse.jpt.eclipselink.core.internal.context.persistence.general.EclipseLinkGeneralProperties;
 import org.eclipse.jpt.eclipselink.core.internal.context.persistence.schema.generation.EclipseLinkSchemaGeneration;
 import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
 import org.eclipse.jpt.utility.internal.iterables.CompositeListIterable;
 import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
 import org.eclipse.jpt.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -505,4 +508,16 @@ public class EclipseLinkPersistenceUnit
 	      }
 	   };
 	}
+
+
+	// ********** refactoring **********
+
+	@SuppressWarnings("unchecked")
+	@Override
+	protected Iterable<ReplaceEdit> createPersistenceUnitPropertiesReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			super.createPersistenceUnitPropertiesReplaceTypeEdits(originalType, newName),
+			this.customization.createReplaceTypeEdits(originalType, newName),
+			this.logging.createReplaceTypeEdits(originalType, newName));
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/customization/EclipseLinkCustomization.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/customization/EclipseLinkCustomization.java
index 1affa8f1af..1cafe1ce7b 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/customization/EclipseLinkCustomization.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/customization/EclipseLinkCustomization.java
@@ -16,14 +16,19 @@ import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.eclipselink.core.context.persistence.customization.Customization;
 import org.eclipse.jpt.eclipselink.core.context.persistence.customization.Profiler;
 import org.eclipse.jpt.eclipselink.core.context.persistence.customization.Weaving;
 import org.eclipse.jpt.eclipselink.core.internal.context.persistence.EclipseLinkPersistenceUnitProperties;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  *  EclipseLinkCustomization
@@ -795,4 +800,34 @@ public class EclipseLinkCustomization extends EclipseLinkPersistenceUnitProperti
 	public int entitiesSize() {
 		return this.entities.size();
 	}
+
+
+	// ********** refactoring ************
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+					this.createSessionCustomizerReplaceTypeEdits(originalType, newName),
+					this.createExceptionHandlerReplaceTypeEdits(originalType, newName));
+	}
+
+	protected Iterable<ReplaceEdit> createSessionCustomizerReplaceTypeEdits(final IType originalType, final String newName) {
+		return new CompositeIterable<ReplaceEdit>(
+			new TransformationIterable<PersistenceUnit.Property, Iterable<ReplaceEdit>>(getPersistenceUnit().getPropertiesNamed(ECLIPSELINK_SESSION_CUSTOMIZER)) {
+				@Override
+				protected Iterable<ReplaceEdit> transform(PersistenceUnit.Property property) {
+					return property.createReplaceTypeEdits(originalType, newName);
+				}
+			}
+		);
+	}
+
+	protected Iterable<ReplaceEdit> createExceptionHandlerReplaceTypeEdits(IType originalType, String newName) {
+		PersistenceUnit.Property property = getPersistenceUnit().getProperty(ECLIPSELINK_EXCEPTION_HANDLER);
+		if (property != null) {
+			return property.createReplaceTypeEdits(originalType, newName);
+		}
+		return EmptyIterable.instance();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/logging/EclipseLinkLogging.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/logging/EclipseLinkLogging.java
index 6b1f41d01d..f8b24d1d02 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/logging/EclipseLinkLogging.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/logging/EclipseLinkLogging.java
@@ -10,12 +10,15 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.persistence.logging;
 
 import java.util.Map;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.eclipselink.core.context.persistence.logging.Logger;
 import org.eclipse.jpt.eclipselink.core.context.persistence.logging.Logging;
 import org.eclipse.jpt.eclipselink.core.context.persistence.logging.LoggingLevel;
 import org.eclipse.jpt.eclipselink.core.internal.context.persistence.EclipseLinkPersistenceUnitProperties;
 import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  *  EclipseLinkLogging
@@ -358,4 +361,21 @@ public class EclipseLinkLogging extends EclipseLinkPersistenceUnitProperties
 		return DEFAULT_LOGGER;
 	}
 
+
+	// ********** refactoring ************
+
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return this.createLoggerReplaceTypeEdits(originalType, newName);
+	}
+
+	protected Iterable<ReplaceEdit> createLoggerReplaceTypeEdits(IType originalType, String newName) {
+		//TODO seems like we should have the Property stored in a SessionCustomizer object instead of having to go 
+		//find all of the Properties from the persistence unit.
+		PersistenceUnit.Property property = getPersistenceUnit().getProperty(ECLIPSELINK_LOGGER);
+		if (property != null) {
+			return property.createReplaceTypeEdits(originalType, newName);
+		}
+		return EmptyIterable.instance();
+	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/options/EclipseLinkOptions.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/options/EclipseLinkOptions.java
index 95783f0f39..e91beab105 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/options/EclipseLinkOptions.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/persistence/options/EclipseLinkOptions.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (c) 2008, 2009 Oracle. All rights reserved.
+* Copyright (c) 2008, 2010 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.
@@ -10,11 +10,14 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.persistence.options;
 
 import java.util.Map;
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.eclipselink.core.context.persistence.options.Options;
 import org.eclipse.jpt.eclipselink.core.context.persistence.options.TargetDatabase;
 import org.eclipse.jpt.eclipselink.core.context.persistence.options.TargetServer;
 import org.eclipse.jpt.eclipselink.core.internal.context.persistence.EclipseLinkPersistenceUnitProperties;
+import org.eclipse.jpt.utility.internal.iterables.EmptyIterable;
+import org.eclipse.text.edits.ReplaceEdit;
 
 /**
  *  EclipseLinkOptions
@@ -396,4 +399,19 @@ public class EclipseLinkOptions extends EclipseLinkPersistenceUnitProperties
 		return DEFAULT_TEMPORAL_MUTABLE;
 	}
 
+
+	// ********** refactoring ************
+
+	@Override
+	public Iterable<ReplaceEdit> createReplaceTypeEdits(IType originalType, String newName) {
+		return this.createEventListenerReplaceTypeEdits(originalType, newName);
+	}
+
+	protected Iterable<ReplaceEdit> createEventListenerReplaceTypeEdits(IType originalType, String newName) {
+		PersistenceUnit.Property property = getPersistenceUnit().getProperty(ECLIPSELINK_SESSION_EVENT_LISTENER);
+		if (property != null) {
+			return property.createReplaceTypeEdits(originalType, newName);
+		}
+		return EmptyIterable.instance();
+	}
 }
\ No newline at end of file