refactoring textRange and addToMessages in an effort to support validation of the orm.xml model. do not want references to CompilationUnit in the orm.xml model

100 files changed, 968 insertions, 663 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/ContextModel.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/ContextModel.java
index 385f7d7167..c4dd53273b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/ContextModel.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/ContextModel.java
@@ -11,7 +11,6 @@ package org.eclipse.jpt.core;
 
 import java.util.List;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public interface ContextModel
@@ -24,8 +23,8 @@ public interface ContextModel
 	// ********** validation **********
 	
 	/**
-	 * All subclass implementations {@link #addToMessages(List<IMessage>, CompilationUnit astRoot)} 
+	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
 	 * should be preceded by a "super" call to this method
 	 */
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot);
+	public void addToMessages(List<IMessage> messages);
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaFactory.java
index 357aec644d..36f7586a98 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaFactory.java
@@ -18,6 +18,7 @@ import org.eclipse.jpt.core.context.IBaseJpaContent;
 import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.NamedColumn;
+import org.eclipse.jpt.core.context.java.JavaAbstractJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
@@ -36,6 +37,7 @@ import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.context.java.JavaManyToManyMapping;
 import org.eclipse.jpt.core.context.java.JavaManyToOneMapping;
 import org.eclipse.jpt.core.context.java.JavaMappedSuperclass;
+import org.eclipse.jpt.core.context.java.JavaNamedColumn;
 import org.eclipse.jpt.core.context.java.JavaNamedNativeQuery;
 import org.eclipse.jpt.core.context.java.JavaNamedQuery;
 import org.eclipse.jpt.core.context.java.JavaOneToManyMapping;
@@ -287,9 +289,9 @@ public interface JpaFactory
 	
 	JavaColumn buildJavaColumn(JavaJpaContextNode parent, JavaColumn.Owner owner);
 
-	JavaDiscriminatorColumn buildJavaDiscriminatorColumn(JavaEntity parent, NamedColumn.Owner owner);
+	JavaDiscriminatorColumn buildJavaDiscriminatorColumn(JavaEntity parent, JavaNamedColumn.Owner owner);
 	
-	JavaJoinColumn buildJavaJoinColumn(JavaJpaContextNode parent, JoinColumn.Owner owner);
+	JavaJoinColumn buildJavaJoinColumn(JavaJpaContextNode parent, JavaJoinColumn.Owner owner);
 
 	JavaSecondaryTable buildJavaSecondaryTable(JavaEntity parent);
 	
@@ -299,7 +301,7 @@ public interface JpaFactory
 	
 	JavaGeneratedValue buildJavaGeneratedValue(JavaAttributeMapping parent);
 	
-	JavaPrimaryKeyJoinColumn buildJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, AbstractJoinColumn.Owner owner);
+	JavaPrimaryKeyJoinColumn buildJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, JavaAbstractJoinColumn.Owner owner);
 	
 	JavaAttributeOverride buildJavaAttributeOverride(JavaJpaContextNode parent, AttributeOverride.Owner owner);
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaNode.java
index 867ad7cc52..7e715307c9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaNode.java
@@ -9,12 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.core;
 
-import java.util.List;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IAdaptable;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.utility.internal.node.Node;
-import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 /**
  * Tweak the node interface with JPA-specific protocol.
@@ -33,14 +30,6 @@ public interface JpaNode extends Node, IAdaptable
 	 */
 	IResource resource();
 	
-	
-	// ********** validation **********
-	
-	/**
-	 * Adds to the list of current messages
-	 */
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot);
-
 	// ********** covariant overrides **********
 
 	JpaNode parent();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
index 02f428ec59..4d37c2e032 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core;
 
 import java.util.Iterator;
+import java.util.List;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResourceDelta;
@@ -177,7 +178,11 @@ public interface JpaProject extends JpaNode {
 	 */
 	Iterator<IMessage> validationMessages();
 
-	
+	/**
+	 * Add to the list of current validation messages
+	 */
+	void addToMessages(List<IMessage> messages);
+
 
 	// **************** support for modifying shared documents *****************
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractColumn.java
index 9fc28dbd07..c94d20fc69 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractColumn.java
@@ -9,9 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
-
 
 public interface AbstractColumn extends NamedColumn
 {
@@ -64,11 +61,6 @@ public interface AbstractColumn extends NamedColumn
 	Boolean getSpecifiedUpdatable();
 	void setSpecifiedUpdatable(Boolean newSpecifiedUpdatable);
 		String SPECIFIED_UPDATABLE_PROPERTY = "specifiedUpdatableProperty";
-
-	/**
-	 * Return the (best guess) text location of the column's table.
-	 */
-	TextRange tableTextRange(CompilationUnit astRoot);
 	
 	//TODO not sure we really need/want this to be public.  This
 	//is used by ColumnComposite to get a list of possible associated tables, but
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractJoinColumn.java
index ad7afe7d42..d1be2499ad 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/AbstractJoinColumn.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.db.internal.Column;
 import org.eclipse.jpt.db.internal.Table;
 
@@ -34,11 +32,6 @@ public interface AbstractJoinColumn extends NamedColumn
 	 */
 	boolean isReferencedColumnResolved();
 
-	/**
-	 * Return the (best guess) text location of the referenced column name
-	 */
-	TextRange referencedColumnNameTextRange(CompilationUnit astRoot);
-
 	boolean isVirtual();
 
 	interface Owner extends NamedColumn.Owner
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/BaseOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/BaseOverride.java
index 8b5771749d..e038d42623 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/BaseOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/BaseOverride.java
@@ -9,9 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
-
 
 public interface BaseOverride extends JpaContextNode
 {
@@ -40,7 +37,5 @@ public interface BaseOverride extends JpaContextNode
 		 * embeddable.
 		 */
 		boolean isVirtual(BaseOverride override);
-
-		TextRange validationTextRange(CompilationUnit astRoot);
 	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/GeneratedValue.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/GeneratedValue.java
index d16acd0242..c97010af26 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/GeneratedValue.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/GeneratedValue.java
@@ -9,9 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
-
 
 public interface GeneratedValue extends JpaContextNode
 {
@@ -31,8 +28,4 @@ public interface GeneratedValue extends JpaContextNode
 		String SPECIFIED_GENERATOR_PROPERTY = "specifiedGeneratorProperty";
 		String DEFAULT_GENERATOR_PROPERTY = "defaultGeneratorProperty";
 
-	/**
-	 * Return the (best guess) text location of the generator.
-	 */
-	TextRange generatorTextRange(CompilationUnit astRoot);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NamedColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NamedColumn.java
index 477502895d..a3d6c2f874 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NamedColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NamedColumn.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.db.internal.Column;
 import org.eclipse.jpt.db.internal.Table;
 
@@ -48,11 +46,6 @@ public interface NamedColumn extends JpaContextNode
 	 */
 	boolean isResolved();
 
-	/**
-	 * Return the (best guess) text location of the column's name.
-	 */
-	TextRange nameTextRange(CompilationUnit astRoot);
-
 	Owner owner();
 	/**
 	 * interface allowing columns to be used in multiple places
@@ -66,12 +59,6 @@ public interface NamedColumn extends JpaContextNode
 		TypeMapping typeMapping();
 
 		/**
-		 * Return the column owner's text range. This can be returned by the
-		 * column when its annotation is not present.
-		 */
-		TextRange validationTextRange(CompilationUnit astRoot);
-
-		/**
 		 * Return the wrapper for the datasource table for the given table name
 		 */
 		Table dbTable(String tableName);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NonOwningMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NonOwningMapping.java
index 68ded69297..f127a2130d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NonOwningMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/NonOwningMapping.java
@@ -10,8 +10,6 @@
 package org.eclipse.jpt.core.context;
 
 import java.util.Iterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 
 public interface NonOwningMapping extends RelationshipMapping
 {
@@ -23,5 +21,4 @@ public interface NonOwningMapping extends RelationshipMapping
 
 	boolean mappedByIsValid(AttributeMapping mappedByMapping);
 
-	TextRange mappedByTextRange(CompilationUnit astRoot);
 }
\ No newline at end of file
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 026627bc19..3bf644a661 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
@@ -10,8 +10,10 @@
 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;
 
 
 public interface PersistentType extends JpaContextNode, JpaStructureNode
@@ -88,5 +90,11 @@ public interface PersistentType extends JpaContextNode, JpaStructureNode
 	Iterator<PersistentType> inheritanceHierarchy();
 	
 	
+	// **************** validation **************************************
+
+	/**
+	 * Add to the list of current validation messages
+	 */
+	void addToMessages(List<IMessage> messages);
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/Table.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/Table.java
index f4bdf38f21..c76dcc37b2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/Table.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/Table.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.db.internal.Schema;
 
 public interface Table extends JpaContextNode
@@ -66,11 +64,6 @@ public interface Table extends JpaContextNode
 	 */
 	boolean isResolved();
 
-	TextRange nameTextRange(CompilationUnit astRoot);
-
-	TextRange schemaTextRange(CompilationUnit astRoot);
-	
-	TextRange catalogTextRange(CompilationUnit astRoot);
 
 //
 //	class UniqueConstraintOwner implements IUniqueConstraint.Owner
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractColumn.java
new file mode 100644
index 0000000000..2d10d5d19a
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractColumn.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2008 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.context.java;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.TextRange;
+import org.eclipse.jpt.core.context.AbstractColumn;
+
+
+public interface JavaAbstractColumn extends AbstractColumn, JavaNamedColumn
+{
+
+	/**
+	 * Return the (best guess) text location of the column's table.
+	 */
+	TextRange tableTextRange(CompilationUnit astRoot);
+
+	Owner owner();
+	
+	/**
+	 * interface allowing columns to be used in multiple places
+	 * (e.g. basic mappings and attribute overrides)
+	 */
+	interface Owner extends JavaNamedColumn.Owner, AbstractColumn.Owner
+	{
+
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractJoinColumn.java
new file mode 100644
index 0000000000..5fe2a25c33
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAbstractJoinColumn.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2008 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.context.java;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.TextRange;
+import org.eclipse.jpt.core.context.AbstractJoinColumn;
+
+public interface JavaAbstractJoinColumn extends AbstractJoinColumn, JavaNamedColumn
+{
+
+	/**
+	 * Return the (best guess) text location of the referenced column name
+	 */
+	TextRange referencedColumnNameTextRange(CompilationUnit astRoot);
+
+	
+	Owner owner();
+	/**
+	 * interface allowing join columns to be used in multiple places
+	 * (e.g. 1:1 mappings and join tables)
+	 */
+	interface Owner extends AbstractJoinColumn.Owner, JavaNamedColumn.Owner
+	{
+
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaColumn.java
index e8c91b5110..aec07523fa 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaColumn.java
@@ -9,11 +9,10 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.java;
 
-import org.eclipse.jpt.core.context.AbstractColumn;
 import org.eclipse.jpt.core.context.Column;
 import org.eclipse.jpt.core.resource.java.ColumnAnnotation;
 
-public interface JavaColumn extends JavaNamedColumn, Column
+public interface JavaColumn extends Column, JavaAbstractColumn
 {
 	void initializeFromResource(ColumnAnnotation columnResource);
 	
@@ -26,7 +25,7 @@ public interface JavaColumn extends JavaNamedColumn, Column
 	 * interface allowing columns to be used in multiple places
 	 * (e.g. basic mappings and attribute overrides)
 	 */
-	interface Owner extends AbstractColumn.Owner
+	interface Owner extends JavaAbstractColumn.Owner
 	{
 		ColumnAnnotation columnResource();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaGeneratedValue.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaGeneratedValue.java
index 1a1451fce7..3d820d570d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaGeneratedValue.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaGeneratedValue.java
@@ -9,11 +9,19 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.java;
 
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.GeneratedValue;
 import org.eclipse.jpt.core.resource.java.GeneratedValueAnnotation;
 
 public interface JavaGeneratedValue extends GeneratedValue, JavaJpaContextNode
 {
+
+	/**
+	 * Return the (best guess) text location of the generator.
+	 */
+	TextRange generatorTextRange(CompilationUnit astRoot);
+	
 	void initializeFromResource(GeneratedValueAnnotation generatedValue);
 	
 	void update(GeneratedValueAnnotation generatedValue);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJoinColumn.java
index 2fc33148cb..42b2fc5ea4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJoinColumn.java
@@ -12,7 +12,7 @@ package org.eclipse.jpt.core.context.java;
 import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.resource.java.JoinColumnAnnotation;
 
-public interface JavaJoinColumn extends JoinColumn, JavaNamedColumn
+public interface JavaJoinColumn extends JoinColumn, JavaAbstractJoinColumn, JavaAbstractColumn
 {
 	void initializeFromResource(JoinColumnAnnotation joinColumn);
 	
@@ -20,4 +20,14 @@ public interface JavaJoinColumn extends JoinColumn, JavaNamedColumn
 	
 	void update(JoinColumnAnnotation joinColumn);
 
+	Owner owner();
+	
+	/**
+	 * interface allowing join columns to be used in multiple places
+	 * (e.g. 1:1 mappings and join tables)
+	 */
+	interface Owner extends JoinColumn.Owner, JavaAbstractJoinColumn.Owner, JavaAbstractColumn.Owner
+	{
+
+	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
index 97e12a12d6..5b991dce44 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
@@ -10,19 +10,30 @@
 package org.eclipse.jpt.core.context.java;
 
 import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.utility.internal.Filter;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public interface JavaJpaContextNode extends JpaContextNode
 {
-	TextRange validationTextRange(CompilationUnit astRoot);
 	
 	/**
 	 * Return the Java code-completion proposals for the specified position
 	 * in the source code.
 	 */
 	Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot);
+	
+
+	// ******************** validation ***************************8
+	
+	/**
+	 * Adds to the list of current validation messages
+	 */
+	void addToMessages(List<IMessage> messages, CompilationUnit astRoot);
+
+	TextRange validationTextRange(CompilationUnit astRoot);
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaNamedColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaNamedColumn.java
index a6cecf2558..a49e4b2537 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaNamedColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaNamedColumn.java
@@ -9,10 +9,32 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.java;
 
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.NamedColumn;
 
 
 public interface JavaNamedColumn extends NamedColumn, JavaJpaContextNode
 {
 
+	Owner owner();
+	
+	/**
+	 * Return the (best guess) text location of the column's name.
+	 */
+	TextRange nameTextRange(CompilationUnit astRoot);
+
+	/**
+	 * interface allowing columns to be used in multiple places
+	 * (e.g. basic mappings and attribute overrides)
+	 */
+	interface Owner extends NamedColumn.Owner
+	{
+		/**
+		 * Return the column owner's text range. This can be returned by the
+		 * column when its annotation is not present.
+		 */
+		TextRange validationTextRange(CompilationUnit astRoot);
+
+	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaPrimaryKeyJoinColumn.java
index 84cb19aba7..b7006afd25 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaPrimaryKeyJoinColumn.java
@@ -12,10 +12,10 @@ package org.eclipse.jpt.core.context.java;
 import org.eclipse.jpt.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.resource.java.PrimaryKeyJoinColumnAnnotation;
 
-public interface JavaPrimaryKeyJoinColumn extends PrimaryKeyJoinColumn, JavaNamedColumn
+public interface JavaPrimaryKeyJoinColumn extends PrimaryKeyJoinColumn, JavaAbstractJoinColumn
 {
 	void initializeFromResource(PrimaryKeyJoinColumnAnnotation primaryKeyJoinColumn);
 	
 	void update(PrimaryKeyJoinColumnAnnotation primaryKeyJoinColumn);
-
+	
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
index 4e702c8cc2..9d9b784f11 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
@@ -9,10 +9,20 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.orm;
 
+import java.util.List;
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JpaContextNode;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public interface OrmJpaContextNode extends JpaContextNode
 {
-	//TextRange validationTextRange();
+	// **************** validation **************************************
+
+	/**
+	 * Add to the list of current validation messages
+	 */
+	void addToMessages(List<IMessage> messages);
+
+	TextRange validationTextRange();
 
 }
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 5948b04708..338bc394b8 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
@@ -11,12 +11,10 @@
 package org.eclipse.jpt.core.context.persistence;
 
 import org.eclipse.jpt.core.JpaStructureNode;
-import org.eclipse.jpt.core.TextRange;
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.resource.persistence.XmlJavaClassRef;
 
-public interface ClassRef extends JpaContextNode, JpaStructureNode
+public interface ClassRef extends PersistenceJpaContextNode, JpaStructureNode
 {
 	/**
 	 * Return true if the IClassRef matches the fullyQualfiedTypeName
@@ -82,5 +80,4 @@ public interface ClassRef extends JpaContextNode, JpaStructureNode
 	 */
 	boolean containsOffset(int textOffset);
 	
-	TextRange validationTextRange();
 }
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 b3b0b02972..bc9a05f709 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
@@ -11,13 +11,12 @@
 package org.eclipse.jpt.core.context.persistence;
 
 import org.eclipse.jpt.core.JpaStructureNode;
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.resource.persistence.XmlMappingFileRef;
 
-public interface MappingFileRef extends JpaContextNode, JpaStructureNode
+public interface MappingFileRef extends PersistenceJpaContextNode, JpaStructureNode
 {
 	/**
 	 * Return whether this mapping file ref is represented by an entry in the
@@ -73,4 +72,5 @@ public interface MappingFileRef extends JpaContextNode, JpaStructureNode
 	 * the given text offset
 	 */
 	boolean containsOffset(int textOffset);
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Persistence.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Persistence.java
index c618be0522..255e4f899b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Persistence.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Persistence.java
@@ -12,10 +12,9 @@ package org.eclipse.jpt.core.context.persistence;
 
 import java.util.ListIterator;
 import org.eclipse.jpt.core.JpaStructureNode;
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.resource.persistence.XmlPersistence;
 
-public interface Persistence extends JpaContextNode, JpaStructureNode
+public interface Persistence extends PersistenceJpaContextNode, JpaStructureNode
 {
 	// **************** persistence units **************************************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java
new file mode 100644
index 0000000000..d887b39c08
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2008 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.context.persistence;
+
+import java.util.List;
+import org.eclipse.jpt.core.TextRange;
+import org.eclipse.jpt.core.context.JpaContextNode;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+
+public interface PersistenceJpaContextNode extends JpaContextNode
+{
+	// **************** validation **************************************
+
+	/**
+	 * Add to the list of current validation messages
+	 */
+	void addToMessages(List<IMessage> messages);
+
+	TextRange validationTextRange();
+
+}
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 5d43f4d2d6..7dfe9c9176 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
@@ -11,13 +11,11 @@ package org.eclipse.jpt.core.context.persistence;
 
 import java.util.ListIterator;
 import org.eclipse.jpt.core.JpaStructureNode;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AccessType;
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.resource.persistence.XmlPersistenceUnit;
 
-public interface PersistenceUnit extends JpaContextNode, JpaStructureNode
+public interface PersistenceUnit extends PersistenceJpaContextNode, JpaStructureNode
 {
 	// **************** parent *************************************************
 	
@@ -457,6 +455,5 @@ public interface PersistenceUnit extends JpaContextNode, JpaStructureNode
 	 * the given text offset
 	 */
 	boolean containsOffset(int textOffset);
-	
-	TextRange validationTextRange();
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceXml.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceXml.java
index 0441d4e145..9fb5190af7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceXml.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceXml.java
@@ -11,10 +11,9 @@
 package org.eclipse.jpt.core.context.persistence;
 
 import org.eclipse.jpt.core.JpaStructureNode;
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.resource.persistence.PersistenceResource;
 
-public interface PersistenceXml extends JpaContextNode, JpaStructureNode
+public interface PersistenceXml extends PersistenceJpaContextNode, JpaStructureNode
 {
 	// **************** persistence *******************************************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Property.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Property.java
index 6090e1acb1..98e91fc5bb 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Property.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/Property.java
@@ -10,10 +10,9 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.context.persistence;
 
-import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.resource.persistence.XmlProperty;
 
-public interface Property extends JpaContextNode
+public interface Property extends PersistenceJpaContextNode
 {
 	// **************** name ***************************************************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaNode.java
index e00fec6eb2..8065fd183b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/AbstractJpaNode.java
@@ -12,11 +12,9 @@ package org.eclipse.jpt.core.internal;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Set;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.Platform;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.JpaNode;
 import org.eclipse.jpt.core.JpaPlatform;
@@ -26,7 +24,6 @@ import org.eclipse.jpt.db.internal.Database;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.jpt.utility.internal.node.AbstractNode;
 import org.eclipse.jpt.utility.internal.node.Node;
-import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 /**
  * 
@@ -151,14 +148,5 @@ public abstract class AbstractJpaNode
 	// when you override this method, don't forget to include:
 	//	super.addNonUpdateAspectNamesTo(nonUpdateAspectNames);
 	}
-	
-	// ********** validation **********
-	
-	/**
-	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
-	 * should be preceded by a "super" call to this method
-	 */
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
index fdbef8a730..e7405160e9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
@@ -31,7 +31,6 @@ import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.ContextModel;
 import org.eclipse.jpt.core.JpaDataSource;
 import org.eclipse.jpt.core.JpaFile;
@@ -455,16 +454,13 @@ public class GenericJpaProject extends AbstractJpaNode implements JpaProject {
 	 * persistence unit level.  */
 	private boolean okToContinueValidation = true;
 	
-	
-	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void addToMessages(List<IMessage> messages) {
 		//start with the project - then down
 		//project validation
 		addProjectLevelMessages(messages);
 		
 		//context model validation
-		contextModel().addToMessages(messages, astRoot);
+		contextModel().addToMessages(messages);
 	}
 
 	protected void addProjectLevelMessages(List<IMessage> messages) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/BaseJpaContent.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/BaseJpaContent.java
index 1c5a06c39f..2b4f345a79 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/BaseJpaContent.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/BaseJpaContent.java
@@ -13,7 +13,6 @@ package org.eclipse.jpt.core.internal.context;
 import java.util.List;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaProject;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.context.IBaseJpaContent;
@@ -151,15 +150,13 @@ public class BaseJpaContent extends AbstractJpaContextNode
 	 * persistence unit level.  */
 	private boolean okToContinueValidation = true;
 	
-	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void addToMessages(List<IMessage> messages) {
 		addNoPersistenceXmlMessage(messages);
 		//TODO - multiple persistence unit message
 		addOrphanedJavaClassMessages(messages);
 		
 		if(okToContinueValidation) {
-			getPersistenceXml().addToMessages(messages, astRoot);
+			getPersistenceXml().addToMessages(messages);
 		}
 		
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
index 83a886dcdf..58efe3ecaa 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
@@ -26,7 +26,7 @@ import org.eclipse.jpt.db.internal.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public abstract class AbstractJavaAttributeMapping extends JavaContextModel
+public abstract class AbstractJavaAttributeMapping extends AbstractJavaJpaContextNode
 	implements JavaAttributeMapping
 {
 	protected JavaResourcePersistentAttribute persistentAttributeResource;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaColumn.java
index bebbb3b791..bdcf4c6b3d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaColumn.java
@@ -13,6 +13,7 @@ import java.util.Iterator;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractColumn;
+import org.eclipse.jpt.core.context.java.JavaAbstractColumn;
 import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.resource.java.AbstractColumnAnnotation;
 import org.eclipse.jpt.utility.internal.Filter;
@@ -21,7 +22,7 @@ import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 
 public abstract class AbstractJavaColumn<T extends AbstractColumnAnnotation> extends AbstractJavaNamedColumn<T>
-	implements AbstractColumn
+	implements JavaAbstractColumn
 {
 
 	protected String specifiedTable;
@@ -36,7 +37,7 @@ public abstract class AbstractJavaColumn<T extends AbstractColumnAnnotation> ext
 	
 	protected Boolean specifiedUpdatable;
 
-	protected AbstractJavaColumn(JavaJpaContextNode parent, AbstractColumn.Owner owner) {
+	protected AbstractJavaColumn(JavaJpaContextNode parent, JavaAbstractColumn.Owner owner) {
 		super(parent, owner);
 	}
 	
@@ -52,8 +53,8 @@ public abstract class AbstractJavaColumn<T extends AbstractColumnAnnotation> ext
 	}
 	
 	@Override
-	public AbstractColumn.Owner owner() {
-		return (AbstractColumn.Owner) super.owner();
+	public JavaAbstractColumn.Owner owner() {
+		return (JavaAbstractColumn.Owner) super.owner();
 	}
 
 	//************** IAbstractColumn implementation *******************
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaGenerator.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaGenerator.java
index 2d607c5a05..bc7004172c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaGenerator.java
@@ -17,7 +17,7 @@ import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.resource.java.GeneratorAnnotation;
 
 
-public abstract class AbstractJavaGenerator<T extends GeneratorAnnotation> extends JavaContextModel implements JavaGenerator<T>
+public abstract class AbstractJavaGenerator<T extends GeneratorAnnotation> extends AbstractJavaJpaContextNode implements JavaGenerator<T>
 {
 	protected String name;
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaContextModel.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java
index 110402e0d3..ff573e17b6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaContextModel.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java
@@ -10,17 +10,19 @@
 package org.eclipse.jpt.core.internal.context.java;
 
 import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaNode;
 import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.utility.internal.Filter;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public abstract class JavaContextModel extends AbstractJpaContextNode implements JavaJpaContextNode
+public abstract class AbstractJavaJpaContextNode extends AbstractJpaContextNode implements JavaJpaContextNode
 {
 	// ********** constructor **********
 
-	protected JavaContextModel(JpaNode parent) {
+	protected AbstractJavaJpaContextNode(JpaNode parent) {
 		super(parent);
 	}
 
@@ -44,5 +46,15 @@ public abstract class JavaContextModel extends AbstractJpaContextNode implements
 	public Iterator<String> connectedCandidateValuesFor(int pos, Filter<String> filter, CompilationUnit astRoot) {
 		return null;
 	}
+	
+	// ********** validation **********
+	
+	/**
+	 * All subclass implementations {@link #addToMessages(List, CompilationUnit))} 
+	 * should be preceded by a "super" call to this method
+	 */
+	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
+		
+	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
index d2af769700..833dd96c9c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
@@ -12,12 +12,12 @@ package org.eclipse.jpt.core.internal.context.java;
 import java.util.Iterator;
 import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
 import org.eclipse.jpt.core.context.MultiRelationshipMapping;
 import org.eclipse.jpt.core.context.NonOwningMapping;
 import org.eclipse.jpt.core.context.PersistentAttribute;
-import org.eclipse.jpt.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaJoinTable;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
@@ -370,95 +370,20 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 
 	//******** Validation ***********************************
 	
+	public abstract TextRange mappedByTextRange(CompilationUnit astRoot);
+	
 	@Override
 	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		super.addToMessages(messages, astRoot);
 		
 		if (this.isJoinTableSpecified() || isRelationshipOwner()) {
-			addJoinTableMessages(messages, astRoot);
+			getJoinTable().addToMessages(messages, astRoot);
 		}
 		if (this.getMappedBy() != null) {
 			addMappedByMessages(messages, astRoot);
 		}
 	}
 	
-	protected void addJoinTableMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		JavaJoinTable joinTable = this.getJoinTable();
-		
-		boolean doContinue = joinTable.isConnected();
-		String schema = joinTable.getSchema();
-		
-		if (doContinue && ! joinTable.hasResolvedSchema()) {
-			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_SCHEMA,
-						new String[] {schema, joinTable.getName()}, 
-						joinTable, joinTable.schemaTextRange(astRoot))
-				);
-			doContinue = false;
-		}
-		
-		if (doContinue && ! joinTable.isResolved()) {
-			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_NAME,
-						new String[] {joinTable.getName()}, 
-						joinTable, joinTable.nameTextRange(astRoot))
-				);
-			doContinue = false;
-		}
-		
-		for (Iterator<JavaJoinColumn> stream = joinTable.joinColumns(); stream.hasNext(); ) {
-			JavaJoinColumn joinColumn = stream.next();
-			
-			if (doContinue && ! joinColumn.isResolved()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
-						new String[] {joinColumn.getName()}, 
-						joinColumn, joinColumn.nameTextRange(astRoot))
-				);
-			}
-			
-			if (doContinue && ! joinColumn.isReferencedColumnResolved()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
-						new String[] {joinColumn.getReferencedColumnName(), joinColumn.getName()}, 
-						joinColumn, joinColumn.referencedColumnNameTextRange(astRoot))
-				);
-			}
-		}
-		
-		for (Iterator<JavaJoinColumn> stream = joinTable.inverseJoinColumns(); stream.hasNext(); ) {
-			JavaJoinColumn joinColumn = stream.next();
-			
-			if (doContinue && ! joinColumn.isResolved()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
-						new String[] {joinColumn.getName()}, 
-						joinColumn, joinColumn.nameTextRange(astRoot))
-				);
-			}
-			
-			if (doContinue && ! joinColumn.isReferencedColumnResolved()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
-						new String[] {joinColumn.getReferencedColumnName(), joinColumn.getName()}, 
-						joinColumn, joinColumn.referencedColumnNameTextRange(astRoot))
-				);
-			}
-		}
-	}
-	
 	protected void addMappedByMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		String mappedBy = this.getMappedBy();
 		
@@ -487,7 +412,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
 						new String[] {mappedBy}, 
-						this, this.mappedByTextRange(astRoot))
+						this, 
+						this.mappedByTextRange(astRoot))
 				);
 			return;
 		}
@@ -498,7 +424,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
 						new String[] {mappedBy}, 
-						this, this.mappedByTextRange(astRoot))
+						this, 
+						this.mappedByTextRange(astRoot))
 				);
 			return;
 		}
@@ -516,7 +443,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
-						this, this.mappedByTextRange(astRoot))
+						this, 
+						this.mappedByTextRange(astRoot))
 				);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaNamedColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaNamedColumn.java
index a92a724923..119f465d76 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaNamedColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaNamedColumn.java
@@ -24,7 +24,7 @@ import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 
 
-public abstract class AbstractJavaNamedColumn<T extends NamedColumnAnnotation> extends JavaContextModel
+public abstract class AbstractJavaNamedColumn<T extends NamedColumnAnnotation> extends AbstractJavaJpaContextNode
 	implements JavaNamedColumn
 {
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java
index af5ef00b3c..25db7d4394 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java
@@ -20,7 +20,7 @@ import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 
 
-public abstract class JavaOverride<T extends OverrideAnnotation> extends JavaContextModel implements BaseOverride
+public abstract class AbstractJavaOverride<T extends OverrideAnnotation> extends AbstractJavaJpaContextNode implements BaseOverride
 {
 
 	protected String name;
@@ -29,7 +29,7 @@ public abstract class JavaOverride<T extends OverrideAnnotation> extends JavaCon
 
 	protected T overrideResource;
 	
-	public JavaOverride(JavaJpaContextNode parent, Owner owner) {
+	public AbstractJavaOverride(JavaJpaContextNode parent, Owner owner) {
 		super(parent);
 		this.owner = owner;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaQuery.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaQuery.java
index 357c1e680f..7c12cde818 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaQuery.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaQuery.java
@@ -25,7 +25,7 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 
 
-public abstract class AbstractJavaQuery<E extends QueryAnnotation> extends JavaContextModel implements JavaQuery<E>
+public abstract class AbstractJavaQuery<E extends QueryAnnotation> extends AbstractJavaJpaContextNode implements JavaQuery<E>
 {
 	protected String name;
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
index 1559bcda31..178c6ccf06 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
@@ -270,7 +270,7 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 		return joinColumn;
 	}
 	
-	protected JoinColumn.Owner createJoinColumnOwner() {
+	protected JavaJoinColumn.Owner createJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 	
@@ -356,7 +356,7 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 	}
 	
 
-	public class JoinColumnOwner implements JoinColumn.Owner
+	public class JoinColumnOwner implements JavaJoinColumn.Owner
 	{
 
 		public JoinColumnOwner() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTable.java
index 0f0cc8425f..a84a020ffd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTable.java
@@ -10,10 +10,13 @@
 package org.eclipse.jpt.core.internal.context.java;
 
 import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.Table;
 import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.TableAnnotation;
 import org.eclipse.jpt.db.internal.Schema;
 import org.eclipse.jpt.utility.internal.Filter;
@@ -21,8 +24,9 @@ import org.eclipse.jpt.utility.internal.NameTools;
 import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public abstract class AbstractJavaTable extends JavaContextModel
+public abstract class AbstractJavaTable extends AbstractJavaJpaContextNode
 {
 
 	protected String specifiedName;
@@ -401,4 +405,33 @@ public abstract class AbstractJavaTable extends JavaContextModel
 	public String displayString() {
 		return qualifiedName();
 	}
+	
+	@Override
+	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
+		boolean doContinue = isConnected();
+		String schema = getSchema();
+		
+		if (doContinue && ! hasResolvedSchema()) {
+			messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
+						new String[] {schema, getName()}, 
+						this, 
+						schemaTextRange(astRoot))
+				);
+			doContinue = false;
+		}
+		
+		if (doContinue && ! isResolved()) {
+			messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.TABLE_UNRESOLVED_NAME,
+						new String[] {getName()}, 
+						this, 
+						nameTextRange(astRoot))
+				);
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
index 7380a30f29..cb574b8550 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
@@ -21,7 +21,7 @@ import org.eclipse.jpt.db.internal.Schema;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 
 
-public abstract class AbstractJavaTypeMapping extends JavaContextModel
+public abstract class AbstractJavaTypeMapping extends AbstractJavaJpaContextNode
 	implements JavaTypeMapping
 {
 	protected JavaResourcePersistentType persistentTypeResource;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
index dc8eb4aa97..1c72f14144 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
@@ -18,7 +18,6 @@ import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.AssociationOverride;
 import org.eclipse.jpt.core.context.Entity;
-import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.context.RelationshipMapping;
 import org.eclipse.jpt.core.context.TypeMapping;
 import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
@@ -31,7 +30,7 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.Filter;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 
-public class GenericJavaAssociationOverride extends JavaOverride<AssociationOverrideAnnotation>
+public class GenericJavaAssociationOverride extends AbstractJavaOverride<AssociationOverrideAnnotation>
 	implements JavaAssociationOverride
 {
 
@@ -84,7 +83,7 @@ public class GenericJavaAssociationOverride extends JavaOverride<AssociationOver
 		return joinColumn;
 	}
 	
-	protected JoinColumn.Owner createJoinColumnOwner() {
+	protected JavaJoinColumn.Owner createJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 
@@ -179,7 +178,7 @@ public class GenericJavaAssociationOverride extends JavaOverride<AssociationOver
 		return joinColumn;
 	}
 
-	public class JoinColumnOwner implements JoinColumn.Owner
+	public class JoinColumnOwner implements JavaJoinColumn.Owner
 	{
 
 		public JoinColumnOwner() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
index 129fac769f..3380397d42 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
@@ -23,7 +23,7 @@ import org.eclipse.jpt.db.internal.Table;
 import org.eclipse.jpt.utility.internal.Filter;
 
 
-public class GenericJavaAttributeOverride extends JavaOverride<AttributeOverrideAnnotation>
+public class GenericJavaAttributeOverride extends AbstractJavaOverride<AttributeOverrideAnnotation>
 	implements JavaAttributeOverride
 {
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaDiscriminatorColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaDiscriminatorColumn.java
index 246ec53b2b..8c3f44e593 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaDiscriminatorColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaDiscriminatorColumn.java
@@ -13,9 +13,9 @@ import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.DiscriminatorColumn;
 import org.eclipse.jpt.core.context.DiscriminatorType;
-import org.eclipse.jpt.core.context.NamedColumn;
 import org.eclipse.jpt.core.context.java.JavaDiscriminatorColumn;
 import org.eclipse.jpt.core.context.java.JavaEntity;
+import org.eclipse.jpt.core.context.java.JavaNamedColumn;
 import org.eclipse.jpt.core.resource.java.DiscriminatorColumnAnnotation;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentMember;
 
@@ -29,7 +29,7 @@ public class GenericJavaDiscriminatorColumn extends AbstractJavaNamedColumn<Disc
 	
 	protected JavaResourcePersistentMember persistenceResource;
 	
-	public GenericJavaDiscriminatorColumn(JavaEntity parent, NamedColumn.Owner owner) {
+	public GenericJavaDiscriminatorColumn(JavaEntity parent, JavaNamedColumn.Owner owner) {
 		super(parent, owner);
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
index cbb588a85c..6153bb7226 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
@@ -26,7 +26,6 @@ import org.eclipse.jpt.core.context.DiscriminatorColumn;
 import org.eclipse.jpt.core.context.DiscriminatorType;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.InheritanceType;
-import org.eclipse.jpt.core.context.NamedColumn;
 import org.eclipse.jpt.core.context.NamedNativeQuery;
 import org.eclipse.jpt.core.context.NamedQuery;
 import org.eclipse.jpt.core.context.PersistentAttribute;
@@ -36,10 +35,12 @@ import org.eclipse.jpt.core.context.RelationshipMapping;
 import org.eclipse.jpt.core.context.SecondaryTable;
 import org.eclipse.jpt.core.context.Table;
 import org.eclipse.jpt.core.context.TypeMapping;
+import org.eclipse.jpt.core.context.java.JavaAbstractJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.core.context.java.JavaDiscriminatorColumn;
 import org.eclipse.jpt.core.context.java.JavaEntity;
+import org.eclipse.jpt.core.context.java.JavaNamedColumn;
 import org.eclipse.jpt.core.context.java.JavaNamedNativeQuery;
 import org.eclipse.jpt.core.context.java.JavaNamedQuery;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
@@ -150,7 +151,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		this.defaultAssociationOverrides = new ArrayList<JavaAssociationOverride>();
 	}
 	
-	protected AbstractJoinColumn.Owner createPrimaryKeyJoinColumnOwner() {
+	protected JavaAbstractJoinColumn.Owner createPrimaryKeyJoinColumnOwner() {
 		return new PrimaryKeyJoinColumnOwner();
 	}
 	
@@ -158,8 +159,8 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		return jpaFactory().buildJavaDiscriminatorColumn(this, buildDiscriminatorColumnOwner());
 	}
 	
-	protected NamedColumn.Owner buildDiscriminatorColumnOwner() {
-		return new NamedColumn.Owner(){
+	protected JavaNamedColumn.Owner buildDiscriminatorColumnOwner() {
+		return new JavaNamedColumn.Owner(){
 			public org.eclipse.jpt.db.internal.Table dbTable(String tableName) {
 				return GenericJavaEntity.this.dbTable(tableName);
 			}
@@ -1658,11 +1659,11 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		super.addToMessages(messages, astRoot);
 		
-		addTableMessages(messages, astRoot);
+		getTable().addToMessages(messages, astRoot);
 		addIdMessages(messages, astRoot);
 		
-		for (JavaSecondaryTable context : specifiedSecondaryTables) {
-			context.addToMessages(messages, astRoot);
+		for (Iterator<JavaSecondaryTable> stream = this.specifiedSecondaryTables(); stream.hasNext();) {
+			stream.next().addToMessages(messages, astRoot);
 		}
 
 		for (Iterator<JavaAttributeOverride> stream = this.attributeOverrides(); stream.hasNext();) {
@@ -1675,36 +1676,8 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		
 	}
 	
-	protected void addTableMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		boolean doContinue = table.isConnected();
-		String schema = table.getSchema();
-		
-		if (doContinue && ! table.hasResolvedSchema()) {
-			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
-						new String[] {schema, table.getName()}, 
-						table, table.schemaTextRange(astRoot))
-				);
-			doContinue = false;
-		}
-		
-		if (doContinue && ! table.isResolved()) {
-			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_NAME,
-						new String[] {table.getName()}, 
-						table, table.nameTextRange(astRoot))
-				);
-		}
-	}
-	
-	
 	protected void addIdMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		addNoIdMessage(messages, astRoot);
-		
 	}
 	
 	protected void addNoIdMessage(List<IMessage> messages, CompilationUnit astRoot) {
@@ -1732,7 +1705,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		return false;
 	}
 	
-	class PrimaryKeyJoinColumnOwner implements AbstractJoinColumn.Owner
+	class PrimaryKeyJoinColumnOwner implements JavaAbstractJoinColumn.Owner
 	{
 		public TextRange validationTextRange(CompilationUnit astRoot) {
 			return GenericJavaEntity.this.validationTextRange(astRoot);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaGeneratedValue.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaGeneratedValue.java
index 3910ca968a..957b775f71 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaGeneratedValue.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaGeneratedValue.java
@@ -18,7 +18,7 @@ import org.eclipse.jpt.core.context.java.JavaGeneratedValue;
 import org.eclipse.jpt.core.resource.java.GeneratedValueAnnotation;
 
 
-public class GenericJavaGeneratedValue extends JavaContextModel implements JavaGeneratedValue
+public class GenericJavaGeneratedValue extends AbstractJavaJpaContextNode implements JavaGeneratedValue
 {
 	protected GenerationType strategy;
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
index d8858459a1..eb3ad349e3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
@@ -14,7 +14,6 @@ import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.Entity;
-import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.context.RelationshipMapping;
 import org.eclipse.jpt.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
@@ -36,7 +35,7 @@ public class GenericJavaJoinColumn extends AbstractJavaColumn<JoinColumnAnnotati
 
 	protected JoinColumnAnnotation joinColumn;
 	
-	public GenericJavaJoinColumn(JavaJpaContextNode parent, JoinColumn.Owner owner) {
+	public GenericJavaJoinColumn(JavaJpaContextNode parent, JavaJoinColumn.Owner owner) {
 		super(parent, owner);
 	}
 
@@ -78,8 +77,8 @@ public class GenericJavaJoinColumn extends AbstractJavaColumn<JoinColumnAnnotati
 
 
 	@Override
-	public JoinColumn.Owner owner() {
-		return (JoinColumn.Owner) super.owner();
+	public JavaJoinColumn.Owner owner() {
+		return (JavaJoinColumn.Owner) super.owner();
 	}
 
 	public boolean isVirtual() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
index 8ae3ae18e2..8f2ca074e0 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
@@ -28,6 +28,8 @@ import org.eclipse.jpt.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaJoinTable;
 import org.eclipse.jpt.core.context.java.JavaRelationshipMapping;
 import org.eclipse.jpt.core.internal.resource.java.NullJoinColumn;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.java.JoinColumnAnnotation;
 import org.eclipse.jpt.core.resource.java.JoinTableAnnotation;
@@ -36,6 +38,7 @@ import org.eclipse.jpt.utility.internal.Filter;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.utility.internal.iterators.SingleElementListIterator;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public class GenericJavaJoinTable extends AbstractJavaTable implements JavaJoinTable
 {
@@ -362,11 +365,11 @@ public class GenericJavaJoinTable extends AbstractJavaTable implements JavaJoinT
 		return null;
 	}
 
-	protected JoinColumn.Owner createJoinColumnOwner() {
+	protected JavaJoinColumn.Owner createJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 	
-	protected JoinColumn.Owner createInverseJoinColumnOwner() {
+	protected JavaJoinColumn.Owner createInverseJoinColumnOwner() {
 		return new InverseJoinColumnOwner();
 	}
 
@@ -508,12 +511,89 @@ public class GenericJavaJoinTable extends AbstractJavaTable implements JavaJoinT
 		return joinColumn;
 	}
 
-	
+	@Override
+	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
+		super.addToMessages(messages, astRoot);
+		boolean doContinue = isConnected();
+		String schema = getSchema();
+		
+		if (doContinue && ! hasResolvedSchema()) {
+			messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_SCHEMA,
+						new String[] {schema, getName()}, 
+						this, 
+						schemaTextRange(astRoot))
+				);
+			doContinue = false;
+		}
+		
+		if (doContinue && !isResolved()) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_NAME,
+						new String[] {getName()}, 
+						this, 
+						nameTextRange(astRoot))
+				);
+			doContinue = false;
+		}
+		
+		for (Iterator<JavaJoinColumn> stream = joinColumns(); stream.hasNext(); ) {
+			JavaJoinColumn joinColumn = stream.next();
+			
+			if (doContinue && ! joinColumn.isResolved()) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
+						new String[] {joinColumn.getName()}, 
+						joinColumn, joinColumn.nameTextRange(astRoot))
+				);
+			}
+			
+			if (doContinue && ! joinColumn.isReferencedColumnResolved()) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
+						new String[] {joinColumn.getReferencedColumnName(), joinColumn.getName()}, 
+						joinColumn, joinColumn.referencedColumnNameTextRange(astRoot))
+				);
+			}
+		}
+		
+		for (Iterator<JavaJoinColumn> stream = inverseJoinColumns(); stream.hasNext(); ) {
+			JavaJoinColumn joinColumn = stream.next();
+			
+			if (doContinue && ! joinColumn.isResolved()) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
+						new String[] {joinColumn.getName()}, 
+						joinColumn, joinColumn.nameTextRange(astRoot))
+				);
+			}
+			
+			if (doContinue && ! joinColumn.isReferencedColumnResolved()) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
+						new String[] {joinColumn.getReferencedColumnName(), joinColumn.getName()}, 
+						joinColumn, joinColumn.referencedColumnNameTextRange(astRoot))
+				);
+			}
+		}
+	}		
 	
 	/**
 	 * just a little common behavior
 	 */
-	abstract class AbstractJoinColumnOwner implements JoinColumn.Owner
+	abstract class AbstractJoinColumnOwner implements JavaJoinColumn.Owner
 	{
 		AbstractJoinColumnOwner() {
 			super();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
index 0a95da0e26..baee4966b5 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
@@ -28,7 +28,7 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.Filter;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericJavaPersistentAttribute extends JavaContextModel
+public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 	implements JavaPersistentAttribute
 {
 	protected String name;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
index da6e050f2f..0a94c5ad4e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
@@ -39,7 +39,7 @@ import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericJavaPersistentType extends JavaContextModel implements JavaPersistentType
+public class GenericJavaPersistentType extends AbstractJavaJpaContextNode implements JavaPersistentType
 {
 	protected String name;
 	
@@ -469,16 +469,15 @@ public class GenericJavaPersistentType extends JavaContextModel implements JavaP
 	}
 
 	//*************** Validation ******************************************
+	public void addToMessages(List<IMessage> messages) {
+		//get astRoot here to pass down
+		addToMessages(messages, this.persistentTypeResource.getMember().astRoot());	
+	}
+	
 	@Override
 	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-	
-		//get astRoot here to pass down
-		astRoot = persistentTypeResource.getMember().astRoot();
-		mapping.addToMessages(messages, astRoot);
-		
+		this.mapping.addToMessages(messages, astRoot);	
 		addAttributeMessages(messages, astRoot);
-		
 	}
 	
 	protected void addAttributeMessages(List<IMessage> messages, CompilationUnit astRoot) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPrimaryKeyJoinColumn.java
index 6861fb10b9..de80267ae0 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPrimaryKeyJoinColumn.java
@@ -12,7 +12,7 @@ package org.eclipse.jpt.core.internal.context.java;
 import java.util.Iterator;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
-import org.eclipse.jpt.core.context.AbstractJoinColumn;
+import org.eclipse.jpt.core.context.java.JavaAbstractJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.context.java.JavaPrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.resource.java.PrimaryKeyJoinColumnAnnotation;
@@ -33,7 +33,7 @@ public class GenericJavaPrimaryKeyJoinColumn extends AbstractJavaNamedColumn<Pri
 
 	protected PrimaryKeyJoinColumnAnnotation primaryKeyJoinColumnResource;
 	
-	public GenericJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, AbstractJoinColumn.Owner owner) {
+	public GenericJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, JavaAbstractJoinColumn.Owner owner) {
 		super(parent, owner);
 	}
 
@@ -47,8 +47,8 @@ public class GenericJavaPrimaryKeyJoinColumn extends AbstractJavaNamedColumn<Pri
 
 	//************** JavaNamedColumn implementation ***************
 	@Override
-	public AbstractJoinColumn.Owner owner() {
-		return (AbstractJoinColumn.Owner) super.owner();
+	public JavaAbstractJoinColumn.Owner owner() {
+		return (JavaAbstractJoinColumn.Owner) super.owner();
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaQueryHint.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaQueryHint.java
index 3407fac5a0..3bca7e7d00 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaQueryHint.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaQueryHint.java
@@ -16,7 +16,7 @@ import org.eclipse.jpt.core.context.java.JavaQuery;
 import org.eclipse.jpt.core.context.java.JavaQueryHint;
 import org.eclipse.jpt.core.resource.java.QueryHintAnnotation;
 
-public class GenericJavaQueryHint extends JavaContextModel implements JavaQueryHint
+public class GenericJavaQueryHint extends AbstractJavaJpaContextNode implements JavaQueryHint
 {
 	protected String name;
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
index 5e6ed3b8fc..01c9d29034 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
@@ -20,6 +20,7 @@ import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.context.SecondaryTable;
 import org.eclipse.jpt.core.context.TypeMapping;
+import org.eclipse.jpt.core.context.java.JavaAbstractJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaEntity;
 import org.eclipse.jpt.core.context.java.JavaPrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaSecondaryTable;
@@ -251,7 +252,7 @@ public class GenericJavaSecondaryTable extends AbstractJavaTable
 		return primaryKeyJoinColumn;
 	}
 	
-	protected AbstractJoinColumn.Owner createPrimaryKeyJoinColumnOwner() {
+	protected JavaAbstractJoinColumn.Owner createPrimaryKeyJoinColumnOwner() {
 		return new PrimaryKeyJoinColumnOwner();
 	}
 	
@@ -277,7 +278,7 @@ public class GenericJavaSecondaryTable extends AbstractJavaTable
 		return false;
 	}
 	
-	class PrimaryKeyJoinColumnOwner implements AbstractJoinColumn.Owner
+	class PrimaryKeyJoinColumnOwner implements JavaAbstractJoinColumn.Owner
 	{
 		public TextRange validationTextRange(CompilationUnit astRoot) {
 			return GenericJavaSecondaryTable.this.validationTextRange(astRoot);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaCascade.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaCascade.java
index 624a0d70b2..f79ff37f60 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaCascade.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaCascade.java
@@ -15,7 +15,7 @@ import org.eclipse.jpt.core.context.Cascade;
 import org.eclipse.jpt.core.context.java.JavaRelationshipMapping;
 import org.eclipse.jpt.core.resource.java.RelationshipMappingAnnotation;
 
-public class JavaCascade extends JavaContextModel implements Cascade
+public class JavaCascade extends AbstractJavaJpaContextNode implements Cascade
 {
 	protected boolean all;
 
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 84f348e70e..e8e103cb76 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
@@ -9,6 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import java.util.List;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.NonOwningMapping;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
@@ -30,11 +31,14 @@ import org.eclipse.jpt.core.context.orm.OrmSingleRelationshipMapping;
 import org.eclipse.jpt.core.context.orm.OrmTransientMapping;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmVersionMapping;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
+import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping> extends AbstractJpaContextNode
+public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping> extends AbstractOrmJpaContextNode
 	implements OrmAttributeMapping
 {
 	protected String name;
@@ -217,4 +221,61 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 	public TextRange selectionTextRange() {
 		return this.attributeMapping.selectionTextRange();
 	}
+	
+	
+	public TextRange validationTextRange() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	public TextRange nameTextRange() {
+		return this.attributeMapping.nameTextRange();
+	}
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		addUnspecifiedAttributeMessage(messages);
+		addUnresolvedAttributeMessage(messages);
+		addInvalidMappingMessage(messages);
+	}
+	
+	protected void addUnspecifiedAttributeMessage(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(getName())) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNSPECIFIED_NAME,
+					this, 
+					validationTextRange())
+			);
+		}
+	}
+	
+	protected void addUnresolvedAttributeMessage(List<IMessage> messages) {
+		if (! StringTools.stringIsEmpty(getName())
+				&& javaPersistentAttribute() == null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNRESOLVED_NAME,
+					new String[] {getName(), persistentAttribute().persistentType().getMapping().getClass_()},
+					this, nameTextRange())
+			);
+		}
+	}
+	
+	protected void addInvalidMappingMessage(List<IMessage> messages) {
+		if (! typeMapping().attributeMappingKeyAllowed(getKey())) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENT_ATTRIBUTE_INVALID_MAPPING,
+					new String[] {getName()},
+					this, 
+					validationTextRange())
+			);
+		}
+	}
+	
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmColumn.java
index 252db2dbc1..884ab219a9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmColumn.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractColumn;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlAbstractColumn;
@@ -246,11 +244,7 @@ public abstract class AbstractOrmColumn<T extends XmlAbstractColumn> extends Abs
 	protected String tableName() {
 		return this.getTable();
 	}
-	
-	public TextRange tableTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
+
 //
 //	public ITextRange tableTextRange() {
 //		if (node == null) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmGenerator.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmGenerator.java
index d9d1d1fd45..2c33897c0b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmGenerator.java
@@ -9,13 +9,13 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.JpaContextNode;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlGenerator;
 
 
-public abstract class AbstractOrmGenerator<T extends XmlGenerator> extends AbstractJpaContextNode implements Generator
+public abstract class AbstractOrmGenerator<T extends XmlGenerator> extends AbstractOrmJpaContextNode implements Generator
 {
 
 	protected String name;
@@ -144,5 +144,7 @@ public abstract class AbstractOrmGenerator<T extends XmlGenerator> extends Abstr
 		return generatorResource.getAllocationSize();
 	}
 
-
+	public TextRange validationTextRange() {
+		return this.generatorResource().validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java
new file mode 100644
index 0000000000..cdcb1f0a0e
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.context.orm;
+
+import java.util.List;
+import org.eclipse.jpt.core.JpaNode;
+import org.eclipse.jpt.core.context.orm.OrmJpaContextNode;
+import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+
+public abstract class AbstractOrmJpaContextNode extends AbstractJpaContextNode implements OrmJpaContextNode
+{
+	// ********** constructor **********
+
+	protected AbstractOrmJpaContextNode(JpaNode parent) {
+		super(parent);
+	}
+	
+	// ********** validation **********
+	
+	/**
+	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
+	 * should be preceded by a "super" call to this method
+	 */
+	public void addToMessages(List<IMessage> messages) {
+		
+	}
+
+}
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 0695ad1d43..0fcb56be4d 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
@@ -9,7 +9,6 @@
 package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.FetchType;
@@ -244,7 +243,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends XmlMultiRela
 //		return JavaMultiRelationshipMapping.javaDefaultTargetEntityFromContainer(typeBinding);
 //	}
 	
-	public TextRange mappedByTextRange(CompilationUnit astRoot) {
+	public TextRange mappedByTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmNamedColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmNamedColumn.java
index 4d5e461088..fb2efee447 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmNamedColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmNamedColumn.java
@@ -9,17 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.NamedColumn;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlNamedColumn;
 import org.eclipse.jpt.db.internal.Column;
 import org.eclipse.jpt.db.internal.Table;
 
 
-public abstract class AbstractOrmNamedColumn<T extends XmlNamedColumn>  extends AbstractJpaContextNode
+public abstract class AbstractOrmNamedColumn<T extends XmlNamedColumn>  extends AbstractOrmJpaContextNode
 	implements NamedColumn
 {
 	protected Owner owner;
@@ -143,10 +141,11 @@ public abstract class AbstractOrmNamedColumn<T extends XmlNamedColumn>  extends
 		return dbColumn() != null;
 	}
 
-	public TextRange nameTextRange(CompilationUnit astRoot) {
+	public TextRange nameTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
+	
 //	public ITextRange nameTextRange() {
 //		if (node == null) {
 //			return owner.validationTextRange();
@@ -154,10 +153,11 @@ public abstract class AbstractOrmNamedColumn<T extends XmlNamedColumn>  extends
 //		IDOMNode nameNode = (IDOMNode) DOMUtilities.getChildAttributeNode(node, OrmXmlMapper.NAME);
 //		return (nameNode == null) ? validationTextRange() : buildTextRange(nameNode);
 //	}
-//
-//	public void refreshDefaults(DefaultsContext defaultsContext) {
-//		setDefaultName((String) defaultsContext.getDefault(GenericJpaPlatform.DEFAULT_COLUMN_NAME_KEY));
-//	}
+
+	public TextRange validationTextRange() {
+		return columnResource().validationTextRange();
+	}
+
 	
 	// ******************* initialization from orm xml resource model ********************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmQuery.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmQuery.java
index ad61dbb1a7..8e8e891094 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmQuery.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmQuery.java
@@ -12,19 +12,19 @@ package org.eclipse.jpt.core.internal.context.orm;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.Query;
 import org.eclipse.jpt.core.context.QueryHint;
 import org.eclipse.jpt.core.context.orm.OrmQuery;
 import org.eclipse.jpt.core.context.orm.OrmQueryHint;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlQuery;
 import org.eclipse.jpt.core.resource.orm.XmlQueryHint;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 
 
-public abstract class AbstractOrmQuery<E extends XmlQuery> extends AbstractJpaContextNode implements OrmQuery
+public abstract class AbstractOrmQuery<E extends XmlQuery> extends AbstractOrmJpaContextNode implements OrmQuery
 {
 
 	protected String name;
@@ -152,5 +152,8 @@ public abstract class AbstractOrmQuery<E extends XmlQuery> extends AbstractJpaCo
 		}
 	}
 
+	public TextRange validationTextRange() {
+		return this.queryResource.validationTextRange();
+	}
 
 }
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 ffdfdecb94..c4611dbe4a 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
@@ -9,7 +9,6 @@
 package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
 import org.eclipse.jpt.core.context.Fetchable;
@@ -191,11 +190,6 @@ public abstract class AbstractOrmRelationshipMapping<T extends XmlRelationshipMa
 //	protected String buildReferenceEntityTypeName(ITypeBinding typeBinding) {
 //		return JavaRelationshipMapping.buildReferenceEntityTypeName(typeBinding);
 //	}
-	
-	public String fullyQualifiedTargetEntity(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 		
 	public Entity getEntity() {
 		// TODO Auto-generated method stub
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
index 60a5d0fd61..be0bb04d83 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
@@ -11,8 +11,6 @@ package org.eclipse.jpt.core.internal.context.orm;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
@@ -272,11 +270,6 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 			// TODO Auto-generated method stub
 			return null;
 		}
-		
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
 
 		public int joinColumnsSize() {
 			return AbstractOrmSingleRelationshipMapping.this.joinColumnsSize();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTable.java
index 0eb3e6a880..1a6b21388e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTable.java
@@ -9,16 +9,14 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.Table;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlAbstractTable;
 import org.eclipse.jpt.db.internal.Schema;
 import org.eclipse.jpt.utility.internal.NameTools;
 
-public abstract class AbstractOrmTable extends AbstractJpaContextNode implements Table
+public abstract class AbstractOrmTable extends AbstractOrmJpaContextNode implements Table
 {
 	protected String specifiedName;
 
@@ -186,21 +184,20 @@ public abstract class AbstractOrmTable extends AbstractJpaContextNode implements
 //	}
 
 
-	public TextRange nameTextRange(CompilationUnit astRoot) {
+	public TextRange nameTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 	
-	public TextRange catalogTextRange(CompilationUnit astRoot) {
+	public TextRange catalogTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 	
-	public TextRange schemaTextRange(CompilationUnit astRoot) {
+	public TextRange schemaTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
-	
 //	public ITextRange nameTextRange() {
 //		if (node == null) {
 //			return owner.validationTextRange();
@@ -216,15 +213,10 @@ public abstract class AbstractOrmTable extends AbstractJpaContextNode implements
 //		IDOMNode schemaNode = (IDOMNode) DOMUtilities.getChildAttributeNode(node, OrmXmlMapper.SCHEMA);
 //		return (schemaNode == null) ? validationTextRange() : buildTextRange(schemaNode);
 //	}
-//
-//	@Override
-//	public ITextRange validationTextRange() {
-//		return (node == null) ? owner.validationTextRange() : super.validationTextRange();
-//	}
-//
-//	public Owner getOwner() {
-//		return owner;
-//	}
+	
+	public TextRange validationTextRange() {
+		return this.table().validationTextRange();
+	}
 
 	public org.eclipse.jpt.db.internal.Table dbTable() {
 		Schema schema = this.dbSchema();
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 68c9aed365..e8649bb141 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
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AccessType;
@@ -18,15 +19,18 @@ import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.orm.AbstractTypeMapping;
 import org.eclipse.jpt.db.internal.Schema;
 import org.eclipse.jpt.db.internal.Table;
+import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public abstract class AbstractOrmTypeMapping<T extends AbstractTypeMapping> extends AbstractJpaContextNode implements OrmTypeMapping
+public abstract class AbstractOrmTypeMapping<T extends AbstractTypeMapping> extends AbstractOrmJpaContextNode implements OrmTypeMapping
 {
 
 	protected String class_;
@@ -152,22 +156,6 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractTypeMapping> exte
 		return null;
 	}
 
-//	public ITextRange classTextRange() {
-//		IDOMNode classNode = (IDOMNode) DOMUtilities.getChildAttributeNode(node, OrmXmlMapper.CLASS);
-//		if (classNode != null) {
-//			return buildTextRange(classNode);
-//		}
-//		return validationTextRange();
-//	}
-//
-//	public ITextRange attributesTextRange() {
-//		IDOMNode attributesNode = (IDOMNode) DOMUtilities.getNodeChild(node, OrmXmlMapper.ATTRIBUTES);
-//		if (attributesNode != null) {
-//			return buildTextRange(attributesNode);
-//		}
-//		return validationTextRange();
-//	}
-
 	/**
 	 * @see TypeMapping#attributeMappingKeyAllowed(String)
 	 * 
@@ -295,6 +283,14 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractTypeMapping> exte
 	public TextRange selectionTextRange() {
 		return this.typeMapping.selectionTextRange();
 	}
+	
+	public TextRange classTextRange() {
+		return this.typeMapping.classTextRange();
+	}
+	
+	public TextRange attributesTextRange() {
+		return this.typeMapping.attributesTextRange();
+	}
 
 	public boolean containsOffset(int textOffset) {
 		if (typeMapping == null) {
@@ -302,4 +298,45 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractTypeMapping> exte
 		}
 		return typeMapping.containsOffset(textOffset);
 	}
+	
+	//************************* validation ************************
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		addClassMessages(messages);
+	}
+	protected void addClassMessages(List<IMessage> messages) {
+		addUnspecifiedClassMessage(messages);
+		addUnresolvedClassMessage(messages);
+	}
+	
+	protected void addUnspecifiedClassMessage(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(getClass_())) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENT_TYPE_UNSPECIFIED_CLASS,
+					this, 
+					this.classTextRange())
+			);
+		}
+	}
+	
+	protected void addUnresolvedClassMessage(List<IMessage> messages) {
+		if (! StringTools.stringIsEmpty(getClass_())
+				&& getJavaPersistentType() == null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENT_TYPE_UNRESOLVED_CLASS,
+					new String[] {getClass_()},
+					this, 
+					this.classTextRange())
+			);
+		}
+	}
+
+	public TextRange validationTextRange() {
+		return this.typeMapping.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
index d5c00c4822..2bdd16bb9b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
@@ -30,7 +30,6 @@ import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.AbstractTypeMapping;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlEmbeddable;
@@ -43,9 +42,10 @@ import org.eclipse.jpt.core.resource.orm.XmlSequenceGenerator;
 import org.eclipse.jpt.core.resource.orm.XmlTableGenerator;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericEntityMappings extends AbstractJpaContextNode implements EntityMappings
+public class GenericEntityMappings extends AbstractOrmJpaContextNode implements EntityMappings
 {
 	protected XmlEntityMappings xmlEntityMappings;
 	
@@ -729,4 +729,16 @@ public class GenericEntityMappings extends AbstractJpaContextNode implements Ent
 	public TextRange selectionTextRange() {
 		return xmlEntityMappings.selectionTextRange();
 	}
+	
+	public TextRange validationTextRange() {
+		return null;
+	}
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		for (OrmPersistentType ormPersistentType : CollectionTools.iterable(this.ormPersistentTypes())) {
+			ormPersistentType.addToMessages(messages);
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAssociationOverride.java
index 7b9d56b145..5821508a38 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAssociationOverride.java
@@ -12,7 +12,6 @@ package org.eclipse.jpt.core.internal.context.orm;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.AssociationOverride;
@@ -24,14 +23,13 @@ import org.eclipse.jpt.core.context.RelationshipMapping;
 import org.eclipse.jpt.core.context.TypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmAssociationOverride;
 import org.eclipse.jpt.core.context.orm.OrmJoinColumn;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlAssociationOverride;
 import org.eclipse.jpt.core.resource.orm.XmlJoinColumn;
 import org.eclipse.jpt.db.internal.Table;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 
-public class GenericOrmAssociationOverride extends AbstractJpaContextNode
+public class GenericOrmAssociationOverride extends AbstractOrmJpaContextNode
 	implements OrmAssociationOverride
 {
 
@@ -177,6 +175,11 @@ public class GenericOrmAssociationOverride extends AbstractJpaContextNode
 		return ormJoinColumn;
 	}
 
+	public TextRange validationTextRange() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
 	class JoinColumnOwner implements JoinColumn.Owner
 	{
 
@@ -219,11 +222,6 @@ public class GenericOrmAssociationOverride extends AbstractJpaContextNode
 			return true;
 		}
 
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
-
 		public TypeMapping typeMapping() {
 			return GenericOrmAssociationOverride.this.owner.typeMapping();
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
index 5674ec8ad8..b271d83ef4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
@@ -9,7 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AttributeOverride;
 import org.eclipse.jpt.core.context.BaseOverride;
@@ -17,14 +16,13 @@ import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.TypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmAttributeOverride;
 import org.eclipse.jpt.core.context.orm.OrmColumn;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.db.internal.Table;
 
 
-public class GenericOrmAttributeOverride extends AbstractJpaContextNode
+public class GenericOrmAttributeOverride extends AbstractOrmJpaContextNode
 	implements OrmAttributeOverride, OrmColumn.Owner
 {
 
@@ -68,11 +66,6 @@ public class GenericOrmAttributeOverride extends AbstractJpaContextNode
 		return this.column;
 	}
 
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
 	public TypeMapping typeMapping() {
 		return owner().typeMapping();
 	}
@@ -102,6 +95,11 @@ public class GenericOrmAttributeOverride extends AbstractJpaContextNode
 //		}
 //		return super.validationTextRange();
 //	}
+	public TextRange validationTextRange() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
 
 	//***************** IXmlColumn.Owner implementation ****************
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
index f51b765279..24842cfb4a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
@@ -9,9 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.BasicMapping;
 import org.eclipse.jpt.core.context.ColumnMapping;
 import org.eclipse.jpt.core.context.EnumType;
@@ -200,11 +198,6 @@ public class GenericOrmBasicMapping extends AbstractOrmAttributeMapping<XmlBasic
 	public Table dbTable(String tableName) {
 		return typeMapping().dbTable(tableName);
 	}
-
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 	
 	@Override
 	public void initialize(XmlBasic basic) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedIdMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedIdMapping.java
index a430de2e8f..21662d3be8 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedIdMapping.java
@@ -13,9 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AttributeOverride;
 import org.eclipse.jpt.core.context.BaseOverride;
 import org.eclipse.jpt.core.context.ColumnMapping;
@@ -148,11 +146,6 @@ public class GenericOrmEmbeddedIdMapping extends AbstractOrmAttributeMapping<Xml
 		return GenericJavaEmbeddedMapping.columnMapping(attributeName, embeddable());
 	}
 
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
 //
 //	public EList<IAttributeOverride> getAttributeOverrides() {
 //		EList<IAttributeOverride> list = new EObjectEList<IAttributeOverride>(IAttributeOverride.class, this, OrmPackage.XML_EMBEDDED__ATTRIBUTE_OVERRIDES);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedMapping.java
index c795283a9b..79276a5459 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEmbeddedMapping.java
@@ -13,9 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AttributeOverride;
 import org.eclipse.jpt.core.context.BaseOverride;
 import org.eclipse.jpt.core.context.ColumnMapping;
@@ -148,11 +146,6 @@ public class GenericOrmEmbeddedMapping extends AbstractOrmAttributeMapping<XmlEm
 		return GenericJavaEmbeddedMapping.columnMapping(attributeName, embeddable());
 	}
 
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
 //
 //	public EList<IAttributeOverride> getAttributeOverrides() {
 //		EList<IAttributeOverride> list = new EObjectEList<IAttributeOverride>(IAttributeOverride.class, this, OrmPackage.XML_EMBEDDED__ATTRIBUTE_OVERRIDES);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
index 38b746431f..225f526204 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
@@ -13,9 +13,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.AssociationOverride;
 import org.eclipse.jpt.core.context.AttributeOverride;
@@ -149,10 +147,6 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 				return GenericOrmEntity.this.dbTable(tableName);
 			}
 
-			public TextRange validationTextRange(CompilationUnit astRoot) {
-				return GenericOrmEntity.this.validationTextRange(astRoot);
-			}
-
 			public TypeMapping typeMapping() {
 				return GenericOrmEntity.this;
 			}
@@ -1412,39 +1406,39 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	//**********  Validation **************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		table.addToMessages(messages, astRoot);	
-		addIdMessages(messages, astRoot);
-		
-		
-		for (OrmSecondaryTable context : specifiedSecondaryTables) {
-			context.addToMessages(messages, astRoot);
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		getTable().addToMessages(messages);	
+		addIdMessages(messages);
+		//TODO what about virtual secondary tables??		
+		for (OrmSecondaryTable secondaryTable : CollectionTools.iterable(specifiedSecondaryTables())) {
+			secondaryTable.addToMessages(messages);
 		}
 
 		for (Iterator<OrmAttributeOverride> stream = this.attributeOverrides(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().addToMessages(messages);
 		}
 		
 		for (Iterator<OrmAssociationOverride> stream = this.associationOverrides(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().addToMessages(messages);
 		}
 	
 	}
 	
-	protected void addIdMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		addNoIdMessage(messages, astRoot);
+	protected void addIdMessages(List<IMessage> messages) {
+		addNoIdMessage(messages);
 		
 	}
 	
-	protected void addNoIdMessage(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void addNoIdMessage(List<IMessage> messages) {
 		if (entityHasNoId()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.ENTITY_NO_ID,
 					new String[] {this.getName()},
-					this, this.validationTextRange(astRoot))
+					this, 
+					this.validationTextRange())
 			);
 		}
 	}
@@ -1462,12 +1456,6 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 		return false;
 	}
 	
-	
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-	
 	public TypeMapping typeMapping() {
 		return this;
 	}
@@ -1491,10 +1479,6 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	
 	class PrimaryKeyJoinColumnOwner implements AbstractJoinColumn.Owner
 	{
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			return GenericOrmEntity.this.validationTextRange(astRoot);
-		}
-
 		public TypeMapping typeMapping() {
 			return GenericOrmEntity.this;
 		}
@@ -1548,11 +1532,6 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 		public TypeMapping typeMapping() {
 			return GenericOrmEntity.this;
 		}
-
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
 		
 	}
 
@@ -1580,11 +1559,5 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 		public TypeMapping typeMapping() {
 			return GenericOrmEntity.this;
 		}
-
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
-		
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmGeneratedValue.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmGeneratedValue.java
index 7409e5c343..8a9c6ee085 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmGeneratedValue.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmGeneratedValue.java
@@ -9,16 +9,14 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.GeneratedValue;
 import org.eclipse.jpt.core.context.GenerationType;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.orm.OrmGeneratedValue;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlGeneratedValue;
 
-public class GenericOrmGeneratedValue extends AbstractJpaContextNode implements OrmGeneratedValue
+public class GenericOrmGeneratedValue extends AbstractOrmJpaContextNode implements OrmGeneratedValue
 {
 
 	protected GenerationType specifiedStrategy;
@@ -88,7 +86,7 @@ public class GenericOrmGeneratedValue extends AbstractJpaContextNode implements
 		firePropertyChanged(SPECIFIED_GENERATOR_PROPERTY, oldGenerator, newSpecifiedGenerator);
 	}
 
-	public TextRange generatorTextRange(CompilationUnit astRoot) {
+	public TextRange generatorTextRange() {
 		// TODO Auto-generated method stub
 		return null;
 	}
@@ -125,4 +123,8 @@ public class GenericOrmGeneratedValue extends AbstractJpaContextNode implements
 	protected String generator(XmlGeneratedValue generatedValue) {
 		return generatedValue.getGenerator();
 	}
+	
+	public TextRange validationTextRange() {
+		return this.generatedValue.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
index 22250509ec..c790411c24 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
@@ -9,9 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.ColumnMapping;
 import org.eclipse.jpt.core.context.TemporalType;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
@@ -223,11 +221,6 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 	public String defaultTableName() {
 		return typeMapping().tableName();
 	}
-
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 	
 	@Override
 	public void initialize(XmlId id) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
index c530b81736..a3f6bfd917 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.orm.OrmJoinColumn;
@@ -119,11 +117,6 @@ public class GenericOrmJoinColumn extends AbstractOrmColumn<XmlJoinColumn> imple
 		//joinColumns are part of a collection, the pk-join-column element will be removed/added
 		//when the XmlJoinColumn is removed/added to the XmlEntity collection
 	}
-
-	public TextRange referencedColumnNameTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 	
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
index f805d6c227..c59392b26f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
@@ -12,8 +12,6 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.Entity;
@@ -482,11 +480,6 @@ public class GenericOrmJoinTable extends AbstractOrmTable implements OrmJoinTabl
 			return null;
 		}
 		
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
-		
 		public int joinColumnsSize() {
 			return GenericOrmJoinTable.this.inverseJoinColumnsSize();
 		}
@@ -554,11 +547,6 @@ public class GenericOrmJoinTable extends AbstractOrmTable implements OrmJoinTabl
 			return null;
 		}
 		
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			// TODO Auto-generated method stub
-			return null;
-		}
-		
 		public int joinColumnsSize() {
 			return GenericOrmJoinTable.this.joinColumnsSize();
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
index e7d1a94a3e..06886e38fd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
@@ -9,7 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AttributeMapping;
@@ -69,7 +68,7 @@ public class GenericOrmOneToOneMapping extends AbstractOrmSingleRelationshipMapp
 		return (mappedByKey == MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
 	}
 
-	public TextRange mappedByTextRange(CompilationUnit astRoot) {
+	public TextRange mappedByTextRange() {
 		return null;
 //		if (node == null) {
 //			return typeMapping().validationTextRange();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
index acc961362f..8d5da9bde7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
@@ -31,7 +31,6 @@ import org.eclipse.jpt.core.context.orm.OrmStructureNodes;
 import org.eclipse.jpt.core.context.orm.OrmTransientMapping;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmVersionMapping;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlBasic;
 import org.eclipse.jpt.core.resource.orm.XmlEmbedded;
 import org.eclipse.jpt.core.resource.orm.XmlEmbeddedId;
@@ -42,9 +41,10 @@ import org.eclipse.jpt.core.resource.orm.XmlOneToMany;
 import org.eclipse.jpt.core.resource.orm.XmlOneToOne;
 import org.eclipse.jpt.core.resource.orm.XmlTransient;
 import org.eclipse.jpt.core.resource.orm.XmlVersion;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericOrmPersistentAttribute extends AbstractJpaContextNode
+public class GenericOrmPersistentAttribute extends AbstractOrmJpaContextNode
 	implements OrmPersistentAttribute
 {
 
@@ -345,7 +345,19 @@ public class GenericOrmPersistentAttribute extends AbstractJpaContextNode
 		return this.attributeMapping.selectionTextRange();
 	}
 	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		getMapping().addToMessages(messages);
+	}
+
 	
+	public TextRange validationTextRange() {
+		if (isVirtual()) {
+			return persistentType().validationTextRange();
+		}
+		return this.attributeMapping.validationTextRange();
+	}	
 	@Override
 	public void toString(StringBuilder sb) {
 		super.toString(sb);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
index aa846d2c33..dc11f5e9e4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
@@ -43,7 +43,6 @@ import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmStructureNodes;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.AbstractTypeMapping;
 import org.eclipse.jpt.core.resource.orm.Attributes;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
@@ -69,9 +68,10 @@ import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
 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.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericOrmPersistentType extends AbstractJpaContextNode implements OrmPersistentType
+public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implements OrmPersistentType
 {
 	protected final List<OrmPersistentAttribute> specifiedPersistentAttributes;
 
@@ -799,4 +799,21 @@ public class GenericOrmPersistentType extends AbstractJpaContextNode implements
 	public TextRange selectionTextRange() {
 		return this.ormTypeMapping.selectionTextRange();
 	}
+	
+	//******************** validation **********************
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+
+		getMapping().addToMessages(messages);
+		
+		for (OrmPersistentAttribute persistentAttribute : CollectionTools.iterable(this.attributes())) {
+			persistentAttribute.addToMessages(messages);
+		}
+	}
+	
+	public TextRange validationTextRange() {
+		return this.ormTypeMapping.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumn.java
index 7be520f5cc..47801b973b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumn.java
@@ -9,8 +9,6 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.orm.OrmPrimaryKeyJoinColumn;
@@ -96,10 +94,6 @@ public class GenericOrmPrimaryKeyJoinColumn extends AbstractOrmNamedColumn<XmlPr
 		return dbReferencedColumn() != null;
 	}
 
-	public TextRange referencedColumnNameTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 //	public ITextRange referencedColumnNameTextRange() {
 //		if (node == null) {
 //			return owner.validationTextRange();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmQueryHint.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmQueryHint.java
index 588faa981e..18e8f472e3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmQueryHint.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmQueryHint.java
@@ -9,14 +9,14 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.QueryHint;
 import org.eclipse.jpt.core.context.orm.OrmQuery;
 import org.eclipse.jpt.core.context.orm.OrmQueryHint;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.XmlQueryHint;
 
 
-public class GenericOrmQueryHint extends AbstractJpaContextNode implements OrmQueryHint
+public class GenericOrmQueryHint extends AbstractOrmJpaContextNode implements OrmQueryHint
 {
 
 	protected String name;
@@ -62,4 +62,8 @@ public class GenericOrmQueryHint extends AbstractJpaContextNode implements OrmQu
 		this.setName(queryHint.getName());
 		this.setValue(queryHint.getValue());
 	}
+	
+	public TextRange validationTextRange() {
+		return this.queryHint.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
index 67f72e7be4..31517ff5f1 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
@@ -12,8 +12,6 @@ package org.eclipse.jpt.core.internal.context.orm;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AbstractJoinColumn;
 import org.eclipse.jpt.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.context.SecondaryTable;
@@ -207,10 +205,6 @@ public class GenericOrmSecondaryTable extends AbstractOrmTable
 	
 	class PrimaryKeyJoinColumnOwner implements AbstractJoinColumn.Owner
 	{
-		public TextRange validationTextRange(CompilationUnit astRoot) {
-			//TODO textRange
-			return null;//return GenericOrmSecondaryTable.this.validationTextRange(astRoot);
-		}
 
 		public TypeMapping typeMapping() {
 			return GenericOrmSecondaryTable.this.ormEntity();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
index 4d326b52da..6a8ec8ae04 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
@@ -11,7 +11,6 @@ package org.eclipse.jpt.core.internal.context.orm;
 
 import java.util.List;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.InheritanceType;
 import org.eclipse.jpt.core.context.java.JavaEntity;
@@ -128,10 +127,10 @@ public class GenericOrmTable extends AbstractOrmTable implements OrmTable
 	
 	//******* Validation *******************************
 	
+	//******* Validation *******************************
+	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
+	public void addToMessages(List<IMessage> messages) {
 		boolean doContinue = isConnected();
 		String schema = this.getSchema();
 		
@@ -141,7 +140,7 @@ public class GenericOrmTable extends AbstractOrmTable implements OrmTable
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
 						new String[] {schema, this.getName()}, 
-						this, this.schemaTextRange(astRoot))
+						this, this.schemaTextRange())
 				);
 			doContinue = false;
 		}
@@ -152,7 +151,7 @@ public class GenericOrmTable extends AbstractOrmTable implements OrmTable
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.TABLE_UNRESOLVED_NAME,
 						new String[] {this.getName()}, 
-						this, this.nameTextRange(astRoot))
+						this, this.nameTextRange())
 				);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTransientMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTransientMapping.java
index e8376c68dc..9bb88bf0d4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTransientMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTransientMapping.java
@@ -9,6 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import java.util.List;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
@@ -16,6 +17,7 @@ import org.eclipse.jpt.core.context.orm.OrmTransientMapping;
 import org.eclipse.jpt.core.resource.orm.AbstractTypeMapping;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlTransient;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
 public class GenericOrmTransientMapping extends AbstractOrmAttributeMapping<XmlTransient> implements OrmTransientMapping
@@ -60,4 +62,47 @@ public class GenericOrmTransientMapping extends AbstractOrmAttributeMapping<XmlT
 	public void update(XmlTransient transientResource) {
 		super.update(transientResource);
 	}
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+//		addModifierMessages(messages);
+	}
+	
+//	protected void addModifierMessages(List<IMessage> messages) {
+//		OrmPersistentAttribute attribute = persistentAttribute();
+//		
+//		if (attribute.getMapping().getKey() != MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY
+//				&& attribute.getAttribute() != null 
+//				&& attribute.getAttribute().isField()) {
+//			int flags;
+//			try {
+//				flags = attribute.getAttribute().getJdtMember().getFlags();
+//			} catch (JavaModelException jme) { 
+//				/* no error to log, in that case */ 
+//				return;
+//			}
+//			
+//			if (Flags.isFinal(flags)) {
+//				messages.add(
+//					DefaultJpaValidationMessages.buildMessage(
+//						IMessage.HIGH_SEVERITY,
+//						JpaValidationMessages.PERSISTENT_ATTRIBUTE_FINAL_FIELD,
+//						new String[] {attribute.getName()},
+//						attribute, attribute.validationTextRange())
+//				);
+//			}
+//			
+//			if (Flags.isPublic(flags)) {
+//				messages.add(
+//					DefaultJpaValidationMessages.buildMessage(
+//						IMessage.HIGH_SEVERITY,
+//						JpaValidationMessages.PERSISTENT_ATTRIBUTE_PUBLIC_FIELD,
+//						new String[] {attribute.getName()},
+//						attribute, attribute.validationTextRange())
+//				);
+//				
+//			}
+//		}
+//	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
index 2b239e76bd..c667dba35a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
@@ -9,9 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.ColumnMapping;
 import org.eclipse.jpt.core.context.TemporalType;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
@@ -103,11 +101,6 @@ public class GenericOrmVersionMapping extends AbstractOrmAttributeMapping<XmlVer
 	public Table dbTable(String tableName) {
 		return typeMapping().dbTable(tableName);
 	}
-
-	public TextRange validationTextRange(CompilationUnit astRoot) {
-		// TODO Auto-generated method stub
-		return null;
-	}
 	
 	@Override
 	public void initialize(XmlVersion version) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitDefaults.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitDefaults.java
index 2755e4bc6a..e8e8959add 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitDefaults.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitDefaults.java
@@ -9,16 +9,16 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.AccessType;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
 import org.eclipse.jpt.core.resource.orm.XmlPersistenceUnitDefaults;
 import org.eclipse.jpt.core.resource.orm.XmlPersistenceUnitMetadata;
 
-public class GenericPersistenceUnitDefaults extends AbstractJpaContextNode
+public class GenericPersistenceUnitDefaults extends AbstractOrmJpaContextNode
 	implements PersistenceUnitDefaults
 {
 	protected String schema;
@@ -209,4 +209,10 @@ public class GenericPersistenceUnitDefaults extends AbstractJpaContextNode
 		return this.entityMappings.getPersistenceUnitMetadata();
 	}
 
+	public TextRange validationTextRange() {
+		if (persistenceUnitDefaults() != null) {
+			return persistenceUnitDefaults().validationTextRange();
+		}
+		return this.entityMappings.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitMetadata.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitMetadata.java
index 913e22277b..748aba96f0 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitMetadata.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericPersistenceUnitMetadata.java
@@ -9,15 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.orm.EntityMappings;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
 import org.eclipse.jpt.core.resource.orm.XmlPersistenceUnitMetadata;
 
-public class GenericPersistenceUnitMetadata extends AbstractJpaContextNode
+public class GenericPersistenceUnitMetadata extends AbstractOrmJpaContextNode
 	implements PersistenceUnitMetadata
 {
 	protected boolean xmlMappingMetadataComplete;
@@ -85,5 +85,11 @@ public class GenericPersistenceUnitMetadata extends AbstractJpaContextNode
 	protected XmlPersistenceUnitMetadata persistenceUnitMetadata() {
 		return this.entityMappings.getPersistenceUnitMetadata();
 	}
-
+	
+	public TextRange validationTextRange() {
+		if (persistenceUnitMetadata() != null) {
+			return persistenceUnitMetadata().validationTextRange();
+		}
+		return this.entityMappings.validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmCascade.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmCascade.java
index 95aeb77292..cb71dcd0d9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmCascade.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmCascade.java
@@ -9,16 +9,16 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.Cascade;
 import org.eclipse.jpt.core.context.orm.OrmJpaContextNode;
 import org.eclipse.jpt.core.context.orm.OrmRelationshipMapping;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.CascadeType;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlRelationshipMapping;
 
 
-public class OrmCascade extends AbstractJpaContextNode implements Cascade, OrmJpaContextNode
+public class OrmCascade extends AbstractOrmJpaContextNode implements Cascade, OrmJpaContextNode
 {
 
 	protected boolean all;
@@ -240,4 +240,7 @@ public class OrmCascade extends AbstractJpaContextNode implements Cascade, OrmJp
 		return cascade == null ? false : cascade.isCascadeRefresh();
 	}
 
+	public TextRange validationTextRange() {
+		return this.cascadeResource().validationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
index 2a48b3c0ce..7300a03085 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
@@ -10,6 +10,7 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import java.util.List;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.TextRange;
@@ -18,12 +19,12 @@ import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.OrmResource;
 import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class OrmXmlImpl extends AbstractJpaContextNode
+public class OrmXmlImpl extends AbstractOrmJpaContextNode
 	implements OrmXml
 {
 	protected OrmResource ormResource;
@@ -144,4 +145,13 @@ public class OrmXmlImpl extends AbstractJpaContextNode
 	public TextRange validationTextRange() {
 		return TextRange.Empty.instance();
 	}
+	
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		if (getEntityMappings() != null) {
+			getEntityMappings().addToMessages(messages);
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java
new file mode 100644
index 0000000000..5a75ea93d0
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.context.persistence;
+
+import java.util.List;
+import org.eclipse.jpt.core.JpaNode;
+import org.eclipse.jpt.core.context.persistence.PersistenceJpaContextNode;
+import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+
+public abstract class AbstractPersistenceJpaContextNode extends AbstractJpaContextNode implements PersistenceJpaContextNode
+{
+	// ********** constructor **********
+
+	protected AbstractPersistenceJpaContextNode(JpaNode parent) {
+		super(parent);
+	}
+	
+	// ********** validation **********
+	
+	/**
+	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
+	 * should be preceded by a "super" call to this method
+	 */
+	public void addToMessages(List<IMessage> messages) {
+		
+	}
+
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
index adf9ebaf32..1591e5adf2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
@@ -11,16 +11,17 @@
 package org.eclipse.jpt.core.internal.context.persistence;
 
 import java.util.List;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.context.persistence.PersistenceStructureNodes;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.persistence.XmlJavaClassRef;
+import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 /**
@@ -28,7 +29,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
  * persistence resource model object XmlJavaClassRef.
  * XmlJavaClassRef corresponds to the class tag in the persistence.xml
  */
-public class GenericClassRef extends AbstractJpaContextNode 
+public class GenericClassRef extends AbstractPersistenceJpaContextNode 
 	implements ClassRef
 {
 	protected XmlJavaClassRef xmlJavaClassRef;
@@ -145,16 +146,43 @@ public class GenericClassRef extends AbstractJpaContextNode
 	
 	// *************************************************************************
 
+	// ************************* validation *********************************
+
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		addUnspecifiedClassMessage(messages);
+		addUnresolvedClassMessage(messages);
 		//classRef might have been empty
-		if(javaPersistentType != null){
-			javaPersistentType.addToMessages(messages, astRoot);
+		if(getJavaPersistentType() != null){
+			getJavaPersistentType().addToMessages(messages);
+		}
+	}
+	
+	protected void addUnspecifiedClassMessage(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(getClassName())) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_CLASS,
+					this, validationTextRange())
+			);
 		}
 	}
 	
+	protected void addUnresolvedClassMessage(List<IMessage> messages) {
+		if (! StringTools.stringIsEmpty(getClassName()) && getJavaPersistentType() == null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_CLASS,
+					new String[] {getClassName()}, 
+					this, 
+					this.validationTextRange())
+			);
+		}
+	}
+
 	public JpaStructureNode structureNode(int textOffset) {
 		return this;
 	}
@@ -163,18 +191,18 @@ public class GenericClassRef extends AbstractJpaContextNode
 		if (isVirtual()) {
 			return false;
 		}
-		return xmlJavaClassRef.containsOffset(textOffset);
+		return this.xmlJavaClassRef.containsOffset(textOffset);
 	}
 	
 	public TextRange selectionTextRange() {
 		if (isVirtual()) {
 			return null;
 		}
-		return xmlJavaClassRef.selectionTextRange();
+		return this.xmlJavaClassRef.selectionTextRange();
 	}
 	
 	public TextRange validationTextRange() {
-		return xmlJavaClassRef.validationTextRange();
+		return this.xmlJavaClassRef.validationTextRange();
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
index 84e7da1a79..24e1e156f9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
@@ -10,6 +10,7 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.internal.context.persistence;
 
+import java.util.List;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.TextRange;
@@ -19,12 +20,15 @@ import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
 import org.eclipse.jpt.core.context.persistence.PersistenceStructureNodes;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
+import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
+import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.orm.OrmArtifactEdit;
 import org.eclipse.jpt.core.resource.orm.OrmResource;
 import org.eclipse.jpt.core.resource.persistence.XmlMappingFileRef;
+import org.eclipse.jpt.utility.internal.StringTools;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericMappingFileRef extends AbstractJpaContextNode 
+public class GenericMappingFileRef extends AbstractPersistenceJpaContextNode 
 	implements MappingFileRef
 {
 	protected XmlMappingFileRef xmlMappingFileRef;
@@ -171,26 +175,79 @@ public class GenericMappingFileRef extends AbstractJpaContextNode
 	}
 	
 	public boolean containsOffset(int textOffset) {
-		if (xmlMappingFileRef == null) {
+		if (this.xmlMappingFileRef == null) {
 			return false;
 		}
-		return xmlMappingFileRef.containsOffset(textOffset);
+		return this.xmlMappingFileRef.containsOffset(textOffset);
 	}
 	
 	public TextRange selectionTextRange() {
 		if (isVirtual()) {
 			return null;
 		}
-		return xmlMappingFileRef.selectionTextRange();
+		return this.xmlMappingFileRef.selectionTextRange();
 	}
 	
 	public TextRange validationTextRange() {
 		if (isVirtual()) {
 			return persistenceUnit().validationTextRange();
 		}
-		return xmlMappingFileRef.validationTextRange();
+		return this.xmlMappingFileRef.validationTextRange();
 	}
 	
+	//**************** Validation *************************
+	
+	@Override
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		this.addUnspecifiedMappingFileMessage(messages);
+		this.addUnresolvedMappingFileMessage(messages);
+		this.addInvalidMappingFileContentMessage(messages);
+		if (getOrmXml() != null) {
+			getOrmXml().addToMessages(messages);
+		}
+	}
+	
+	
+	protected void addUnspecifiedMappingFileMessage(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(getFileName())) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_MAPPING_FILE,
+					this, 
+					validationTextRange())
+			);
+		}
+	}
+	
+	protected void addUnresolvedMappingFileMessage(List<IMessage> messages) {
+		if (!StringTools.stringIsEmpty(getFileName()) && getOrmXml() == null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_MAPPING_FILE,
+					new String[] {getFileName()}, 
+					this, 
+					validationTextRange()) 
+			);
+		}
+	}
+	
+	protected void addInvalidMappingFileContentMessage(List<IMessage> messages) {
+		if (getOrmXml() != null 
+				&& getOrmXml().getEntityMappings() == null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_UNIT_INVALID_MAPPING_FILE,
+					new String[] {getFileName()}, 
+					this,
+					validationTextRange())
+			);
+		}
+	}
+
 	@Override
 	public void toString(StringBuilder sb) {
 		super.toString(sb);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
index 6f28837fb8..628b71a141 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
@@ -14,14 +14,12 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.persistence.Persistence;
 import org.eclipse.jpt.core.context.persistence.PersistenceStructureNodes;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.context.persistence.PersistenceXml;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.persistence.PersistenceFactory;
@@ -31,7 +29,7 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericPersistence extends AbstractJpaContextNode
+public class GenericPersistence extends AbstractPersistenceJpaContextNode
 	implements Persistence
 {	
 	protected XmlPersistence xmlPersistence;
@@ -172,38 +170,39 @@ public class GenericPersistence extends AbstractJpaContextNode
 
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
 		//persistence root validation
 		addNoPersistenceUnitMessage(messages);
 		addMultiplePersistenceUnitMessage(messages);
 		
 		
 		//persistence unit validation
-		for (PersistenceUnit pu : persistenceUnits){
-			pu.addToMessages(messages, astRoot);
+		for (PersistenceUnit pu : CollectionTools.iterable(persistenceUnits())){
+			pu.addToMessages(messages);
 		}
 	}
 	
 	protected void addNoPersistenceUnitMessage(List<IMessage> messages) {
-		if (persistenceUnits.size() == 0) {
+		if (persistenceUnitsSize() == 0) {
 			messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_NO_PERSISTENCE_UNIT,
-						this, this.validationTextRange())
+						this, 
+						this.validationTextRange())
 				);
 		}
 	}
 	
 	protected void addMultiplePersistenceUnitMessage(List<IMessage> messages) {
-		if (persistenceUnits.size() > 1) {
+		if (persistenceUnitsSize() > 1) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
+				DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_MULTIPLE_PERSISTENCE_UNITS,
-						this, this.validationTextRange())
+						this, 
+						this.validationTextRange())
 				);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
index e50b5c07fa..31fd9fb81d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
@@ -18,7 +18,6 @@ import java.util.ListIterator;
 import java.util.NoSuchElementException;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.TextRange;
@@ -33,7 +32,6 @@ import org.eclipse.jpt.core.context.persistence.PersistenceStructureNodes;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnitTransactionType;
 import org.eclipse.jpt.core.context.persistence.Property;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.orm.OrmArtifactEdit;
@@ -48,7 +46,6 @@ import org.eclipse.jpt.core.resource.persistence.XmlProperty;
 import org.eclipse.jpt.db.internal.Schema;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.HashBag;
-import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
@@ -56,7 +53,7 @@ import org.eclipse.jpt.utility.internal.iterators.ReadOnlyCompositeListIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericPersistenceUnit extends AbstractJpaContextNode
+public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	implements PersistenceUnit
 {
 	protected XmlPersistenceUnit xmlPersistenceUnit;
@@ -1016,22 +1013,18 @@ public class GenericPersistenceUnit extends AbstractJpaContextNode
 	// ********** Validation ***********************************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
-		addMappingFileMessages(messages, astRoot);	
-		addClassMessages(messages, astRoot);	
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
+		addMappingFileMessages(messages);	
+		addClassMessages(messages);	
 	}
 	
-	protected void addMappingFileMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void addMappingFileMessages(List<IMessage> messages) {
 		addMultipleMetadataMessages(messages);
-		addUnspecifiedMappingFileMessages(messages);
-		addUnresolvedMappingFileMessages(messages);
-		addInvalidMappingFileContentMessage(messages);
 		addDuplicateMappingFileMessages(messages);
 		
 		for (Iterator<MappingFileRef> stream =  mappingFileRefs(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().addToMessages(messages);
 		}
 	}
 	
@@ -1053,10 +1046,10 @@ public class GenericPersistenceUnit extends AbstractJpaContextNode
 	protected void addDuplicateMappingFileMessages(List<IMessage> messages) {
 		HashBag<String> fileBag = new HashBag<String>(
 				CollectionTools.collection(
-						new TransformationIterator(this.mappingFileRefs()) {
+						new TransformationIterator<MappingFileRef, String>(this.mappingFileRefs()) {
 							@Override
-							protected Object transform(Object next) {
-								return ((MappingFileRef) next).getFileName();
+							protected String transform(MappingFileRef mappingFileRef) {
+								return mappingFileRef.getFileName();
 							}
 						}
 				)
@@ -1068,79 +1061,19 @@ public class GenericPersistenceUnit extends AbstractJpaContextNode
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_MAPPING_FILE,
 						new String[] {mappingFileRef.getFileName()}, 
-						mappingFileRef) //, mappingFileRef.validationTextRange())
+						mappingFileRef/*, 
+						mappingFileRef.validationTextRange()*/)
 				);
 			}
 		}
 	}
-	
-	protected void addUnspecifiedMappingFileMessages(List<IMessage> messages) {
-		for (MappingFileRef mappingFileRef : CollectionTools.collection(this.mappingFileRefs())) {
-			if (mappingFileRef.getFileName() == null || mappingFileRef.getFileName().equals("")) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_MAPPING_FILE,
-						mappingFileRef) //, mappingFileRef.validationTextRange())
-				);
-			}
-		}
-	}
-	
-	protected void addUnresolvedMappingFileMessages(List<IMessage> messages) {
-		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
-			MappingFileRef mappingFileRef = stream.next();
-			if (! (mappingFileRef.getFileName() == null || mappingFileRef.getFileName().equals(""))
-					&& mappingFileRef.getOrmXml() == null) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_MAPPING_FILE,
-						new String[] {mappingFileRef.getFileName()}, 
-						mappingFileRef) //, mappingFileRef.validationTextRange()) 
-				);
-			}
-		}
-	}
-	
-	protected void addInvalidMappingFileContentMessage(List<IMessage> messages) {
-		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
-			MappingFileRef mappingFileRef = (MappingFileRef) stream.next();
-			if (mappingFileRef.getOrmXml() != null 
-					&& mappingFileRef.getOrmXml().getEntityMappings() == null) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_INVALID_MAPPING_FILE,
-						new String[] {mappingFileRef.getFileName()}, 
-						mappingFileRef) //, mappingFileRef.validationTextRange())
-				);
-			}
-		} 
-	}
-	
-	
-	protected void addClassMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		addUnspecifiedClassMessages(messages);
-		addUnresolvedClassMessages(messages);
+		
+	protected void addClassMessages(List<IMessage> messages) {
 //		addInvalidOrRedundantClassMessages(messages);
 		addDuplicateClassMessages(messages);
 		
 		for (ClassRef classRef : CollectionTools.collection(classRefs())) {
-				classRef.addToMessages(messages, astRoot);
-		}
-	}
-	
-	protected void addUnspecifiedClassMessages(List<IMessage> messages) {
-		for (ClassRef javaClassRef : CollectionTools.collection(this.classRefs())) {
-			if (javaClassRef.getJavaPersistentType() == null) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_CLASS,
-						javaClassRef, javaClassRef.validationTextRange())
-				);
-			}
+				classRef.addToMessages(messages);
 		}
 	}
 	
@@ -1171,28 +1104,14 @@ public class GenericPersistenceUnit extends AbstractJpaContextNode
 //		}
 //	}
 	
-	protected void addUnresolvedClassMessages(List<IMessage> messages) {
-		for (ClassRef javaClassRef : specifiedClassRefs) {
-			String javaClass = javaClassRef.getClassName();
-			if (! StringTools.stringIsEmpty(javaClass) && javaClassRef.getJavaPersistentType() == null) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_CLASS,
-						new String[] {javaClass}, 
-						javaClassRef, javaClassRef.validationTextRange())
-				);
-			}
-		}
-	}
 	
 	protected void addDuplicateClassMessages(List<IMessage> messages) {
-		HashBag<String> classNameBag = new HashBag(
+		HashBag<String> classNameBag = new HashBag<String>(
 				CollectionTools.collection(
-						new TransformationIterator(this.classRefs()) {
+						new TransformationIterator<ClassRef, String>(this.classRefs()) {
 							@Override
-							protected Object transform(Object next) {
-								return ((ClassRef) next).getClassName();
+							protected String transform(ClassRef classRef) {
+								return classRef.getClassName();
 							}
 						}
 				)
@@ -1205,12 +1124,13 @@ public class GenericPersistenceUnit extends AbstractJpaContextNode
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_CLASS,
 						new String[] {javaClassRef.getClassName()}, 
-						javaClassRef, javaClassRef.validationTextRange())
+						javaClassRef, 
+						javaClassRef.validationTextRange())
 				);
 			}
 		}
 	}
-	
+		
 	
 	private Collection<PersistenceUnitDefaults> persistenceUnitDefaultsForValidation() {
 		ArrayList<PersistenceUnitDefaults> puDefaults = new ArrayList<PersistenceUnitDefaults>();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
index b1d0c5c6ae..7ffd079403 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
@@ -12,14 +12,12 @@ package org.eclipse.jpt.core.internal.context.persistence;
 
 import java.util.List;
 import org.eclipse.core.resources.IResource;
-import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.IBaseJpaContent;
 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.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.persistence.PersistenceFactory;
@@ -27,7 +25,7 @@ import org.eclipse.jpt.core.resource.persistence.PersistenceResource;
 import org.eclipse.jpt.core.resource.persistence.XmlPersistence;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericPersistenceXml extends AbstractJpaContextNode
+public class GenericPersistenceXml extends AbstractPersistenceJpaContextNode
 	implements PersistenceXml
 {
 	protected PersistenceResource persistenceResource;
@@ -149,20 +147,18 @@ public class GenericPersistenceXml extends AbstractJpaContextNode
 	// **************** validation *********************************************
 	
 	private boolean okToContinueValidation = true;
-	
+
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
+	public void addToMessages(List<IMessage> messages) {
+		super.addToMessages(messages);
 		addInvalidPersistenceXmlContentMessage(messages);
 		
 		if (okToContinueValidation){
-			getPersistence().addToMessages(messages, astRoot);
+			getPersistence().addToMessages(messages);
 		}
 	}
 	
 	protected void addInvalidPersistenceXmlContentMessage(List<IMessage> messages) {
-
 		if (this.persistence == null) {
 			messages.add(
 					DefaultJpaValidationMessages.buildMessage(
@@ -173,5 +169,5 @@ public class GenericPersistenceXml extends AbstractJpaContextNode
 			okToContinueValidation = false;
 		}
 	}
-	
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericProperty.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericProperty.java
index 88c3585f62..397b700e9a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericProperty.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericProperty.java
@@ -9,19 +9,20 @@
  *******************************************************************************/
 package org.eclipse.jpt.core.internal.context.persistence;
 
+import org.eclipse.jpt.core.TextRange;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.context.persistence.Property;
-import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.jpt.core.resource.persistence.XmlProperty;
 
 
-public class GenericProperty extends AbstractJpaContextNode
+public class GenericProperty extends AbstractPersistenceJpaContextNode
 	implements Property
 {
 	protected String name;
 	
 	protected String value;
 	
+	protected XmlProperty property;
 	
 	public GenericProperty(PersistenceUnit parent) {
 		super(parent);
@@ -30,12 +31,13 @@ public class GenericProperty extends AbstractJpaContextNode
 	// **************** name ***************************************************
 	
 	public String getName() {
-		return name;
+		return this.name;
 	}
 	
 	public void setName(String newName) {
-		String oldName = name;
-		name = newName;
+		String oldName = this.name;
+		this.name = newName;
+		this.property.setName(newName);
 		firePropertyChanged(NAME_PROPERTY, oldName, newName);
 	}
 	
@@ -43,12 +45,13 @@ public class GenericProperty extends AbstractJpaContextNode
 	// **************** value **************************************************
 	
 	public String getValue() {
-		return value;
+		return this.value;
 	}
 	
 	public void setValue(String newValue) {
-		String oldValue = value;
-		value = newValue;
+		String oldValue = this.value;
+		this.value = newValue;
+		this.property.setValue(newValue);
 		firePropertyChanged(VALUE_PROPERTY, oldValue, newValue);
 	}
 	
@@ -56,15 +59,22 @@ public class GenericProperty extends AbstractJpaContextNode
 	// **************** updating ***********************************************
 	
 	public void initialize(XmlProperty property) {
-		name = property.getName();
-		value = property.getValue();
+		this.property = property;
+		this.name = property.getName();
+		this.value = property.getValue();
 	}
 	
 	public void update(XmlProperty property) {
+		this.property = property;
 		setName(property.getName());
 		setValue(property.getValue());
 	}
 	
+	// **************** validation ***********************************************
+	
+	public TextRange validationTextRange() {
+		return this.property.validationTextRange();
+	}
 	
 	// **************** toString
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaFactory.java
index 79ffd706a1..a735f5db54 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaFactory.java
@@ -29,6 +29,7 @@ import org.eclipse.jpt.core.context.IBaseJpaContent;
 import org.eclipse.jpt.core.context.JoinColumn;
 import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.NamedColumn;
+import org.eclipse.jpt.core.context.java.JavaAbstractJoinColumn;
 import org.eclipse.jpt.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
@@ -47,6 +48,7 @@ import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.core.context.java.JavaManyToManyMapping;
 import org.eclipse.jpt.core.context.java.JavaManyToOneMapping;
 import org.eclipse.jpt.core.context.java.JavaMappedSuperclass;
+import org.eclipse.jpt.core.context.java.JavaNamedColumn;
 import org.eclipse.jpt.core.context.java.JavaNamedNativeQuery;
 import org.eclipse.jpt.core.context.java.JavaNamedQuery;
 import org.eclipse.jpt.core.context.java.JavaOneToManyMapping;
@@ -178,11 +180,11 @@ import org.eclipse.jpt.core.internal.context.orm.GenericOrmVersionMapping;
 import org.eclipse.jpt.core.internal.context.orm.GenericPersistenceUnitDefaults;
 import org.eclipse.jpt.core.internal.context.orm.GenericPersistenceUnitMetadata;
 import org.eclipse.jpt.core.internal.context.orm.OrmXmlImpl;
-import org.eclipse.jpt.core.internal.context.persistence.GenericPersistenceXml;
 import org.eclipse.jpt.core.internal.context.persistence.GenericClassRef;
 import org.eclipse.jpt.core.internal.context.persistence.GenericMappingFileRef;
 import org.eclipse.jpt.core.internal.context.persistence.GenericPersistence;
 import org.eclipse.jpt.core.internal.context.persistence.GenericPersistenceUnit;
+import org.eclipse.jpt.core.internal.context.persistence.GenericPersistenceXml;
 import org.eclipse.jpt.core.internal.context.persistence.GenericProperty;
 import org.eclipse.jpt.core.internal.jdtutility.DefaultAnnotationEditFormatter;
 import org.eclipse.jpt.core.internal.resource.java.JavaResourceModel;
@@ -367,11 +369,11 @@ public class GenericJpaFactory implements JpaFactory
 		return new GenericJavaColumn(parent, owner);
 	}
 	
-	public JavaDiscriminatorColumn buildJavaDiscriminatorColumn(JavaEntity parent, NamedColumn.Owner owner) {
+	public JavaDiscriminatorColumn buildJavaDiscriminatorColumn(JavaEntity parent, JavaNamedColumn.Owner owner) {
 		return new GenericJavaDiscriminatorColumn(parent, owner);
 	}
 	
-	public JavaJoinColumn buildJavaJoinColumn(JavaJpaContextNode parent, JoinColumn.Owner owner) {
+	public JavaJoinColumn buildJavaJoinColumn(JavaJpaContextNode parent, JavaJoinColumn.Owner owner) {
 		return new GenericJavaJoinColumn(parent, owner);
 	}
 	
@@ -439,7 +441,7 @@ public class GenericJpaFactory implements JpaFactory
 		return new GenericJavaGeneratedValue(parent);
 	}
 	
-	public JavaPrimaryKeyJoinColumn buildJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, AbstractJoinColumn.Owner owner) {
+	public JavaPrimaryKeyJoinColumn buildJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, JavaAbstractJoinColumn.Owner owner) {
 		return new GenericJavaPrimaryKeyJoinColumn(parent, owner);
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
index 5f865450a8..b147dd2f3b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
@@ -273,6 +273,6 @@ public class GenericJpaPlatform implements JpaPlatform
 	// **************** Validation *********************************************
 	
 	public void addToMessages(JpaProject project, List<IMessage> messages) {
-		project.addToMessages(messages, null);
+		project.addToMessages(messages);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractTypeMapping.java
index 14b4be19af..b2b4d3001d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractTypeMapping.java
@@ -13,8 +13,12 @@ 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.jpt.core.TextRange;
+import org.eclipse.jpt.core.internal.emfutility.DOMUtilities;
+import org.eclipse.jpt.core.internal.resource.orm.translators.OrmXmlMapper;
 import org.eclipse.jpt.core.resource.common.AbstractJpaEObject;
 import org.eclipse.jpt.core.resource.common.JpaEObject;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
 
 /**
  * <!-- begin-user-doc -->
@@ -494,5 +498,22 @@ public abstract class AbstractTypeMapping extends AbstractJpaEObject implements
 		result.append(')');
 		return result.toString();
 	}
+	
+
+	public TextRange classTextRange() {
+		IDOMNode classNode = (IDOMNode) DOMUtilities.getChildAttributeNode(node, OrmXmlMapper.CLASS);
+		if (classNode != null) {
+			return buildTextRange(classNode);
+		}
+		return validationTextRange();
+	}
+
+	public TextRange attributesTextRange() {
+		IDOMNode attributesNode = (IDOMNode) DOMUtilities.getNodeChild(node, OrmXmlMapper.ATTRIBUTES);
+		if (attributesNode != null) {
+			return buildTextRange(attributesNode);
+		}
+		return validationTextRange();
+	}
 
 } // TypeMapping