Add ERR_ASO_KEY error for conflicting key-based FK directions across join clauses.

Author: motlin

klass-model-converters/klass-compiler-tests/src/test/inputresources/cool/klass/model/converter/compiler/annotation/association/CompoundJoinMixedKeyTest.klass

@@ -0,0 +1,21 @@
+package dummy
+
+class Source
+{
+    id: Long key;
+    extraId: Long?;
+}
+
+class Target
+{
+    id: Long key;
+    extraId: Long?;
+}
+
+association MixedKeyJoin
+{
+    mixedSource: Source[0..1];
+    mixedTarget: Target[0..1] owned;
+
+    relationship this.id == Target.extraId && this.extraId == Target.id
+}

klass-model-converters/klass-compiler-tests/src/test/java/cool/klass/model/converter/compiler/annotation/association/CompoundJoinMixedKeyTest.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2026 Craig Motlin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cool.klass.model.converter.compiler.annotation.association;
+
+import cool.klass.model.converter.compiler.annotation.AbstractKlassCompilerErrorTestCase;
+
+public class CompoundJoinMixedKeyTest extends AbstractKlassCompilerErrorTestCase {}

klass-model-converters/klass-compiler-tests/src/test/resources/cool/klass/model/converter/compiler/annotation/association/CompoundJoinMixedKeyTest-20-35-ERR_ASO_KEY.log

@@ -0,0 +1,17 @@
+════════════════════════════════════════ ERR_ASO_KEY ════════════════════════════════════════
+Error: Association 'MixedKeyJoin' has foreign keys on both sides: 'Target.extraId' and 'Source.extraId'.
+
+At (CompoundJoinMixedKeyTest.klass:20:36)
+
+ 1║ package dummy
+15║ association MixedKeyJoin
+16║ {
+20║     relationship this.id == Target.extraId && this.extraId == Target.id
+  ║                                    ^^^^^^^         ^^^^^^^
+21║ }
+
+Location:  CompoundJoinMixedKeyTest.klass:20:36
+File:      CompoundJoinMixedKeyTest.klass
+Line:      20
+Character: 36
+═════════════════════════════════════════════════════════════════════════════════════════════

klass-model-converters/klass-compiler/src/main/java/cool/klass/model/converter/compiler/state/criteria/OperatorAntlrCriteria.java

@@ -38,6 +38,7 @@
 import cool.klass.model.converter.compiler.state.value.literal.AbstractAntlrLiteralValue;
 import cool.klass.model.meta.domain.criteria.OperatorCriteriaImpl.OperatorCriteriaBuilder;
 import cool.klass.model.meta.grammar.KlassParser.CriteriaOperatorContext;
+import org.antlr.v4.runtime.ParserRuleContext;
 import org.eclipse.collections.api.list.ImmutableList;
 import org.eclipse.collections.api.list.ListIterable;
 import org.eclipse.collections.api.map.OrderedMap;
@@ -189,13 +190,16 @@ public void addForeignKeys() {
 
 		AntlrDataTypeProperty<?> foreignKeyProperty = isTargetEnd ? thisDataTypeProperty : typeDataTypeProperty;
 		AntlrDataTypeProperty<?> keyProperty = isTargetEnd ? typeDataTypeProperty : thisDataTypeProperty;
-		if (foreignKeyProperty.isKey() && !keyProperty.isKey()) {
-			// This can happen for non-key but unique properties
-			// TODO: Implement unique properties, and assert that the property is EITHER key or unique
-			// throw new AssertionError(foreignKeyProperty);
-		}
-
-		endWithForeignKeys.addForeignKeyPropertyMatchingProperty(foreignKeyProperty, keyProperty);
+		// TODO: Implement unique properties, and assert that the matched key property is EITHER key or unique
+		ParserRuleContext foreignKeyReferenceContext = isTargetEnd
+			? thisMemberReferencePath.getElementContext().memberReference().identifier()
+			: typeMemberReferencePath.getElementContext().memberReference().identifier();
+
+		endWithForeignKeys.addForeignKeyPropertyMatchingProperty(
+			foreignKeyProperty,
+			keyProperty,
+			foreignKeyReferenceContext
+		);
 	}
 
 	@Override
@@ -236,12 +240,10 @@ private AntlrAssociationEnd getEndWithForeignKeys(
 		//     relationship this.queryCriteriaId == Criteria.id
 		// }
 
-		// TODO: These two conditions don't make sense here, because we're only considering one pair of joined properties among several &&-clauses
 		if (thisDataTypeProperty.isKey() && !typeDataTypeProperty.isKey()) {
 			return sourceEnd;
 		}
 
-		// TODO: These two conditions don't make sense here, because we're only considering one pair of joined properties among several &&-clauses
 		if (typeDataTypeProperty.isKey() && !thisDataTypeProperty.isKey()) {
 			return targetEnd;
 		}

klass-model-converters/klass-compiler/src/main/java/cool/klass/model/converter/compiler/state/property/AntlrAssociationEnd.java

@@ -36,6 +36,7 @@
 import cool.klass.model.meta.domain.property.ModifierImpl.ModifierBuilder;
 import cool.klass.model.meta.grammar.KlassParser.AssociationEndContext;
 import cool.klass.model.meta.grammar.KlassParser.IdentifierContext;
+import org.antlr.v4.runtime.ParserRuleContext;
 import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.list.ImmutableList;
 import org.eclipse.collections.api.map.MutableOrderedMap;
@@ -96,6 +97,8 @@ public String toString() {
 
 	private final MutableOrderedMap<AntlrDataTypeProperty<?>, AntlrDataTypeProperty<?>> foreignKeys =
 		OrderedMapAdapter.adapt(new LinkedHashMap<>());
+	private final MutableOrderedMap<AntlrDataTypeProperty<?>, ParserRuleContext> foreignKeyReferenceContexts =
+		OrderedMapAdapter.adapt(new LinkedHashMap<>());
 
 	public AntlrAssociationEnd(
 		@Nonnull AssociationEndContext elementContext,
@@ -345,6 +348,10 @@ public boolean isVersioned() {
 		return this.opposite.isVersion();
 	}
 
+	public AntlrAssociationEnd getOpposite() {
+		return this.opposite;
+	}
+
 	public void setOpposite(@Nonnull AntlrAssociationEnd opposite) {
 		this.opposite = Objects.requireNonNull(opposite);
 	}
@@ -361,15 +368,29 @@ public AssociationEndContext getElementContext() {
 		return (AssociationEndContext) super.getElementContext();
 	}
 
+	public boolean hasForeignKeys() {
+		return this.foreignKeys.notEmpty();
+	}
+
+	public MutableOrderedMap<AntlrDataTypeProperty<?>, AntlrDataTypeProperty<?>> getForeignKeys() {
+		return this.foreignKeys;
+	}
+
 	public void addForeignKeyPropertyMatchingProperty(
 		@Nonnull AntlrDataTypeProperty<?> foreignKeyProperty,
-		@Nonnull AntlrDataTypeProperty<?> keyProperty
+		@Nonnull AntlrDataTypeProperty<?> keyProperty,
+		@Nonnull ParserRuleContext foreignKeyReferenceContext
 	) {
 		this.foreignKeys.put(foreignKeyProperty, keyProperty);
+		this.foreignKeyReferenceContexts.put(foreignKeyProperty, foreignKeyReferenceContext);
 		foreignKeyProperty.setKeyMatchingThisForeignKey(this, keyProperty);
 		keyProperty.setForeignKeyMatchingThisKey(this, foreignKeyProperty);
 	}
 
+	public ParserRuleContext getForeignKeyReferenceContext(@Nonnull AntlrDataTypeProperty<?> foreignKeyProperty) {
+		return this.foreignKeyReferenceContexts.get(foreignKeyProperty);
+	}
+
 	@Override
 	protected IdentifierContext getTypeIdentifier() {
 		return this.getElementContext().classReference().identifier();
@@ -382,8 +403,4 @@ public boolean isSourceEnd() {
 	public boolean isTargetEnd() {
 		return this == this.owningAssociation.getTargetEnd();
 	}
-
-	public AntlrAssociationEnd getOpposite() {
-		return this.opposite;
-	}
 }

klass-model-converters/klass-compiler/src/main/java/cool/klass/model/converter/compiler/state/property/AntlrDataTypeProperty.java

@@ -26,6 +26,7 @@
 import cool.klass.model.converter.compiler.CompilationUnit;
 import cool.klass.model.converter.compiler.annotation.AnnotationSeverity;
 import cool.klass.model.converter.compiler.annotation.CompilerAnnotationHolder;
+import cool.klass.model.converter.compiler.state.AntlrAssociation;
 import cool.klass.model.converter.compiler.state.AntlrClassifier;
 import cool.klass.model.converter.compiler.state.AntlrElement;
 import cool.klass.model.converter.compiler.state.AntlrEnumeration;
@@ -452,6 +453,32 @@ private void reportInvalidForeignKeyProperties(
 			throw new AssertionError(associationEnd);
 		}
 
+		if (associationEnd.isSourceEnd() && associationEnd.getOpposite().hasForeignKeys()) {
+			AntlrAssociationEnd oppositeEnd = associationEnd.getOpposite();
+			AntlrDataTypeProperty<?> oppositeForeignKey = oppositeEnd.getForeignKeys().keysView().getFirst();
+			String message = String.format(
+				"Association '%s' has foreign keys on both sides: '%s.%s' and '%s.%s'.",
+				associationEnd.getOwningAssociation().getName(),
+				this.owningClassifier.getName(),
+				this.getName(),
+				oppositeForeignKey.getOwningClassifier().getName(),
+				oppositeForeignKey.getName()
+			);
+			ParserRuleContext thisReferenceContext = associationEnd.getForeignKeyReferenceContext(this);
+			ParserRuleContext oppositeReferenceContext = oppositeEnd.getForeignKeyReferenceContext(oppositeForeignKey);
+			AntlrAssociation association = associationEnd.getOwningAssociation();
+			compilerAnnotationHolder.add(
+				"ERR_ASO_KEY",
+				message,
+				association,
+				Lists.immutable
+					.<IAntlrElement>with(association.getRelationship())
+					.newWithAll(association.getSurroundingElements())
+					.distinct(),
+				Lists.immutable.with(thisReferenceContext, oppositeReferenceContext)
+			);
+		}
+
 		if (this.isOptional && associationEnd.isToOneRequired()) {
 			String message = String.format(
 				"Association end '%s.%s' has multiplicity [%s] so foreign key '%s.%s' ought to be required.",