[332673] Added validation for duplicate entities. Patch from Nan.

4 files changed, 258 insertions, 44 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
index d75fba9834..bec3be9cf9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaEntity.java
@@ -14,6 +14,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Vector;
+
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaPlatformVariation.Supported;
 import org.eclipse.jpt.core.MappingKeys;
@@ -103,7 +104,9 @@ import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.db.Schema;
 import org.eclipse.jpt.utility.Filter;
 import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.HashBag;
 import org.eclipse.jpt.utility.internal.NotNullFilter;
+import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.Tools;
 import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
 import org.eclipse.jpt.utility.internal.iterables.EmptyListIterable;
@@ -1324,6 +1327,8 @@ public abstract class AbstractJavaEntity
 		this.queryContainer.validate(messages, reporter, astRoot);
 		this.attributeOverrideContainer.validate(messages, reporter, astRoot);
 		this.associationOverrideContainer.validate(messages, reporter, astRoot);
+		this.validateEntityName(messages, reporter, astRoot);
+		this.validateDuplicateEntityNames(messages, reporter, astRoot);
 	}
 
 	@Override
@@ -1331,6 +1336,47 @@ public abstract class AbstractJavaEntity
 		return super.validatesAgainstDatabase() && ! this.isAbstractTablePerClass();
 	}
 
+	protected void validateEntityName(List<IMessage> messages,
+			IReporter reporter, CompilationUnit astRoot) {
+		if (StringTools.stringIsEmpty(this.getName())){
+			messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+							IMessage.HIGH_SEVERITY,
+							JpaValidationMessages.ENTITY_NAME_MISSING,
+							new String[] {this.getPersistentType().getName()}, 
+							this,
+							this.getMappingAnnotation().getNameTextRange(astRoot)
+					)
+			);
+		}
+	}
+
+	protected void validateDuplicateEntityNames(List<IMessage> messages,
+			IReporter reporter, CompilationUnit astRoot) {
+		HashBag<String>  javaEntityNamesExclOverridden = new HashBag<String>();
+		CollectionTools.addAll(javaEntityNamesExclOverridden, this.getPersistenceUnit().javaEntityNamesExclOverridden());
+		HashBag<String>  ormEntityNames = new HashBag<String>();
+		CollectionTools.addAll(ormEntityNames, this.getPersistenceUnit().ormEntityNames());
+		String  javaEntityName = this.getName(); 
+		if ((javaEntityName != null) 
+				// Check whether or not this entity name has duplicates among 
+				// the java entities that are not overridden by orm entities
+				&& ((javaEntityNamesExclOverridden.count(javaEntityName) > 1)
+						//Check whether or not this entity name has duplicates 
+						//with the names of orm entities
+						|| (ormEntityNames.contains(javaEntityName)))) {
+								messages.add(
+										DefaultJpaValidationMessages.buildMessage(
+												IMessage.HIGH_SEVERITY,
+												JpaValidationMessages.PERSISTENCE_UNIT_ENTITY_NAME_ATTRIBUTE_MISSING,
+												new String[] {javaEntityName}, 
+												this, 
+												this.getMappingAnnotation().getNameTextRange(astRoot)
+										)
+								);
+		}
+	}
+
 	protected void validatePrimaryKey(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		this.buildPrimaryKeyValidator(astRoot).validate(messages, reporter);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
index f55426ddac..411bfd35ea 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java
@@ -14,6 +14,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Vector;
+
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IType;
@@ -115,6 +116,7 @@ import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.db.Schema;
 import org.eclipse.jpt.utility.internal.ClassName;
 import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.HashBag;
 import org.eclipse.jpt.utility.internal.NotNullFilter;
 import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.Tools;
@@ -1776,6 +1778,47 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 		this.associationOverrideContainer.validate(messages, reporter);
 		this.generatorContainer.validate(messages, reporter);
 		this.queryContainer.validate(messages, reporter);
+		this.validateEntityName(messages,  reporter);
+		this.validateDuplicateEntityNames(messages, reporter);
+	}
+
+	protected void validateEntityName(List<IMessage> messages, IReporter reporter) {
+		if (StringTools.stringIsEmpty(this.getName())){
+			messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+							IMessage.HIGH_SEVERITY,
+							JpaValidationMessages.ENTITY_NAME_MISSING,
+							new String[] {this.getClass_()}, 
+							this,
+							this.getNameTextRange()
+					)
+			);
+		}
+	}
+
+	protected void validateDuplicateEntityNames(List<IMessage> messages,
+			IReporter reporter) {
+		HashBag<String>  ormEntityNames = new HashBag<String>();
+		CollectionTools.addAll(ormEntityNames, this.getPersistenceUnit().ormEntityNames());
+		HashBag<String>  javaEntityNamesExclOverridden = new HashBag<String>();
+		CollectionTools.addAll(javaEntityNamesExclOverridden, this.getPersistenceUnit().javaEntityNamesExclOverridden());
+		String  name = this.getName();
+		if ((name != null) && 
+					// Check whether or not this entity name has duplicates among the orm entities
+					((ormEntityNames.count(name) > 1) 
+					    // Check whether or not this entity name has duplicates among
+						// the java entities that are not defined in the mapping files
+					   || (javaEntityNamesExclOverridden.contains(name)))) {
+							messages.add(
+									DefaultJpaValidationMessages.buildMessage(
+											IMessage.HIGH_SEVERITY,
+											JpaValidationMessages.PERSISTENCE_UNIT_ENTITY_NAME_ATTRIBUTE_MISSING,
+											new String[] {name}, 
+											this, 
+											this.getClassTextRange()
+									)
+							);
+			} 
 	}
 
 	protected void validatePrimaryKey(List<IMessage> messages, IReporter reporter) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
index 3420e15fe8..2fecfe2ce2 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
@@ -399,6 +399,10 @@ public abstract class AbstractOrmTypeMapping<X extends XmlTypeMapping>
 		return this.xmlTypeMapping.getAttributesTextRange();
 	}
 
+	public TextRange getNameTextRange() {
+		return this.xmlTypeMapping.getNameTextRange();
+	}
+	
 	public boolean containsOffset(int textOffset) {
 		return this.xmlTypeMapping.containsOffset(textOffset);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
index 0a7042d948..b96c6ca838 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceUnit.java
@@ -20,6 +20,7 @@ import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.runtime.CoreException;
@@ -464,6 +465,15 @@ public abstract class AbstractPersistenceUnit
 		return this.getMappingFileRefs().iterator();
 	}
 
+	protected Iterator<String> mappingFileRefNames() {
+		return new TransformationIterator<MappingFileRef, String>(this.mappingFileRefs()) {
+			@Override
+			protected String transform(MappingFileRef mappingFileRef) {
+				return mappingFileRef.getFileName();
+			}
+		};
+	}
+	
 	protected ListIterable<MappingFileRef> getMappingFileRefs() {
 		return (this.impliedMappingFileRef == null) ?
 				this.getSpecifiedMappingFileRefs() :
@@ -696,7 +706,16 @@ public abstract class AbstractPersistenceUnit
 	public int jarFileRefsSize() {
 		return this.jarFileRefs.size();
 	}
-
+	
+	protected Iterator<String> jarFileNames() {
+		return new TransformationIterator<JarFileRef, String>(this.jarFileRefs()) {
+			@Override
+			protected String transform(JarFileRef jarFileRef) {
+				return jarFileRef.getFileName();
+			}
+		};
+	}
+	
 	public JarFileRef addJarFileRef(String fileName) {
 		return this.addJarFileRef(this.jarFileRefs.size(), fileName);
 	}
@@ -808,6 +827,15 @@ public abstract class AbstractPersistenceUnit
 		return this.specifiedClassRefs.size() + this.impliedClassRefs.size();
 	}
 
+	protected Iterator<String> classRefNames() {
+		return new TransformationIterator<ClassRef, String>(this.classRefs()) {
+			@Override
+			protected String transform(ClassRef classRef) {
+				return classRef.getClassName();
+			}
+		};
+	}
+	
 	protected Iterable<PersistentType> getNonNullClassRefPersistentTypes() {
 		return new FilteringIterable<PersistentType>(this.getClassRefPersistentTypes(), NotNullFilter.<PersistentType>instance());
 	}
@@ -1640,15 +1668,6 @@ public abstract class AbstractPersistenceUnit
 		}
 	}
 
-	protected Iterator<String> mappingFileRefNames() {
-		return new TransformationIterator<MappingFileRef, String>(this.mappingFileRefs()) {
-			@Override
-			protected String transform(MappingFileRef mappingFileRef) {
-				return mappingFileRef.getFileName();
-			}
-		};
-	}
-
 	protected void validateClassRefs(List<IMessage> messages, IReporter reporter) {
 		this.checkForDuplicateClasses(messages);
 		for (Iterator<ClassRef> stream = this.classRefs(); stream.hasNext(); ) {
@@ -1657,34 +1676,43 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void checkForDuplicateClasses(List<IMessage> messages) {
-		HashBag<String> classNames = new HashBag<String>();
-		CollectionTools.addAll(classNames, this.classRefNames());
+		HashBag<String> ormMappedClassNames = new HashBag<String>();
+		CollectionTools.addAll(ormMappedClassNames, this.ormMappedClassNames());
+		for (Iterator<PersistentType> ormMappedClasses = this.getMappingFilePersistentTypes().iterator(); ormMappedClasses.hasNext();){
+			PersistentType ormMappedClass = ormMappedClasses.next();
+			String ormMappedClassName = ormMappedClass.getName();
+		if ((ormMappedClassName != null) && (ormMappedClassNames.count(ormMappedClassName) > 1)) {
+						messages.add(
+							DefaultJpaValidationMessages.buildMessage(
+									IMessage.HIGH_SEVERITY,
+									JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_CLASS,
+									new String[] {ormMappedClassName}, 
+									ormMappedClass,
+									ormMappedClass.getSelectionTextRange()
+							)
+					);
+				}
+			}
+		HashBag<String> javaClassNames = new HashBag<String>();
+		CollectionTools.addAll(javaClassNames, this.classRefNames());
 		for (Iterator<ClassRef> stream = this.classRefs(); stream.hasNext(); ) {
 			ClassRef classRef = stream.next();
-			String className = classRef.getClassName();
-			if ((className != null) && (classNames.count(className) > 1)) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_CLASS,
-						new String[] {className},
-						classRef,
-						classRef.getValidationTextRange()
-					)
+			String javaClassName = classRef.getClassName();
+			if ((javaClassName != null) && (!ormMappedClassNames.contains(javaClassName)) 
+					&& (javaClassNames.count(javaClassName) > 1)) {
+					  messages.add(
+						DefaultJpaValidationMessages.buildMessage(
+								IMessage.HIGH_SEVERITY,
+								JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_CLASS,
+								new String[] {javaClassName}, 
+								classRef,
+								classRef.getValidationTextRange()
+						)
 				);
 			}
 		}
 	}
 
-	protected Iterator<String> classRefNames() {
-		return new TransformationIterator<ClassRef, String>(this.classRefs()) {
-			@Override
-			protected String transform(ClassRef classRef) {
-				return classRef.getClassName();
-			}
-		};
-	}
-
 	protected void validateJarFileRefs(List<IMessage> messages, IReporter reporter) {
 		this.checkForDuplicateJarFileRefs(messages);
 		for (JarFileRef each : CollectionTools.iterable(this.jarFileRefs())) {
@@ -1711,16 +1739,6 @@ public abstract class AbstractPersistenceUnit
 		}
 	}
 
-	protected Iterator<String> jarFileNames() {
-		return new TransformationIterator<JarFileRef, String>(this.jarFileRefs()) {
-			@Override
-			protected String transform(JarFileRef jarFileRef) {
-				return jarFileRef.getFileName();
-			}
-		};
-	}
-
-	@SuppressWarnings("unused")
 	protected void validateProperties(List<IMessage> messages, IReporter reporter) {
 		// do nothing by default
 	}
@@ -1728,12 +1746,11 @@ public abstract class AbstractPersistenceUnit
 	public boolean validatesAgainstDatabase() {
 		return this.connectionProfileIsActive();
 	}
-
+	
 	public TextRange getValidationTextRange() {
 		return this.xmlPersistenceUnit.getValidationTextRange();
 	}
 
-
 	// ********** refactoring **********
 
 	public Iterable<DeleteEdit> createDeleteTypeEdits(final IType type) {
@@ -1881,7 +1898,6 @@ public abstract class AbstractPersistenceUnit
 		);
 	}
 
-
 	// ********** misc **********
 
 	public XmlPersistenceUnit getXmlPersistenceUnit() {
@@ -1909,6 +1925,7 @@ public abstract class AbstractPersistenceUnit
 		return this;
 	}
 
+	// ------------------- all entities -----------------
 	public Iterable<Entity> getEntities() {
 		return new SubIterableWrapper<TypeMapping, Entity>(this.getEntities_());
 	}
@@ -1931,6 +1948,110 @@ public abstract class AbstractPersistenceUnit
 			};
 	}
 
+	protected Iterator<String> ormMappedClassNames() {
+		return new TransformationIterator<PersistentType, String>(this.getMappingFilePersistentTypes()) {
+			@Override
+			protected String transform(PersistentType persistentType) {
+				return persistentType.getName();
+			}
+		};
+	}
+
+	// ------------------ orm entities --------------------
+	protected Iterator<String> ormEntityClassNames() {
+		return new TransformationIterator<Entity, String>(this.getOrmEntities()) {
+			@Override
+			protected String transform(Entity ormEntity) {
+				return ormEntity.getPersistentType().getName();
+			}
+		};
+	}
+	
+	public Iterator<String> ormEntityNames() {
+		return new TransformationIterator<Entity, String>(this.getOrmEntities()) {
+			@Override
+			protected String transform(Entity ormEntity) {
+				return ormEntity.getName();
+			}
+		};
+	}
+	
+	public Iterable<Entity> getOrmEntities(){
+		return new SubIterableWrapper<TypeMapping, Entity>(this.getOrmEntities_());
+	}
+	
+	protected Iterable<TypeMapping> getOrmEntities_(){
+		return new FilteringIterable<TypeMapping>(this.getOrmTypeMappings()){
+			@Override
+			protected boolean accept(TypeMapping typeMapping) {
+				return typeMapping instanceof Entity;
+			}
+		};
+	}
+	
+	private Iterable<? extends TypeMapping> getOrmTypeMappings() {
+		return new TransformationIterable<PersistentType, TypeMapping>(this.getMappingFilePersistentTypes()) {
+			@Override
+			protected TypeMapping transform(PersistentType persistentType) {
+				return persistentType.getMapping();
+			}
+		};
+	}
+	
+	//--------------- java entities -----------------
+	protected Iterator<String> javaEntityClassNames(){
+		return new TransformationIterator<Entity, String>(this.getJavaEntities()) {
+			@Override
+			protected String transform(Entity javaEntity) {
+				return javaEntity.getPersistentType().getName();
+			}
+		};
+	}
+
+	public Iterator<String> javaEntityNamesExclOverridden() {
+		HashBag<String> ormMappedClassNames = new HashBag<String>();
+		CollectionTools.addAll(ormMappedClassNames, this.ormMappedClassNames());
+		List<String> javaEntityNamesExclOverridden = new ArrayList<String>();
+		for (Iterator<String> javaEntityClassNames = this.javaEntityClassNames(); javaEntityClassNames.hasNext();){
+			String javaEntityClassName = javaEntityClassNames.next();
+			if (!ormMappedClassNames.contains(javaEntityClassName)) {
+				javaEntityNamesExclOverridden.add((this.getEntity(javaEntityClassName)).getName());
+			}
+		}
+		return javaEntityNamesExclOverridden.iterator();
+	}
+
+	public Iterator<String> javaEntityNames(){
+		return new TransformationIterator<Entity, String>(this.getJavaEntities()) {
+			@Override
+			protected String transform(Entity javaEntity) {
+				return javaEntity.getName();
+			}
+		};
+	}
+
+	public Iterable<Entity> getJavaEntities(){
+		return new SubIterableWrapper<TypeMapping, Entity>(this.getJavaEntities_());
+	}
+	
+	protected Iterable<TypeMapping> getJavaEntities_(){
+		return new FilteringIterable<TypeMapping>(this.getJavaTypeMappings()){
+			@Override
+			protected boolean accept(TypeMapping typeMapping) {
+				return typeMapping instanceof Entity;
+			}
+		};
+	}
+	
+	private Iterable<? extends TypeMapping> getJavaTypeMappings() {
+		return new TransformationIterable<PersistentType, TypeMapping>(this.getNonNullClassPersistentTypes()) {
+			@Override
+			protected TypeMapping transform(PersistentType persistentType) {
+				return persistentType.getMapping();
+			}
+		};
+	}	
+	
 	@SuppressWarnings("unchecked")
 	public Iterable<PersistentType> getPersistentTypes() {
 		return new CompositeIterable<PersistentType>(