2 files changed, 27 insertions, 13 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
index 0700f9f7..2e804b44 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
@@ -15,15 +15,17 @@ import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 
 class DirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Boolean> {
+        private final PartialRelation targetType;
         private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
-        private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
+        private PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
 
         public DirectedCrossReferenceRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
                                                                                  Symbol<TruthValue> concreteSymbol, PartialRelation sourceType,
                                                                                  PartialRelation targetType) {
                 super(adapter, partialSymbol, concreteSymbol);
+                this.targetType = targetType;
+                // Source is always a class, so we can rely on the fact that it is always constructed before this refiner.
                 sourceRefiner = adapter.getRefiner(sourceType);
-                targetRefiner = adapter.getRefiner(targetType);
         }
 
         @Override
@@ -32,6 +34,10 @@ class DirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Bo
                         return false;
                 }
                 if (value.must()) {
+                        if (targetRefiner == null) {
+                                // Access the target refinery lazily, since it may be constructed after this refiner.
+                                targetRefiner = getAdapter().getRefiner(targetType);
+                        }
                         return sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
                                         targetRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
                 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
index ad0288ed..74022fc6 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
@@ -153,15 +153,11 @@ public class MetamodelBuilder {
                         return;
                 }
                 var sourceType = info.sourceType();
-                var targetType = info.targetType();
                 if (typeHierarchyBuilder.isInvalidType(sourceType)) {
                         throw new TranslationException(linkType, "Source type %s of %s is not in type hierarchy"
                                         .formatted(sourceType, linkType));
                 }
-                if (typeHierarchyBuilder.isInvalidType(targetType)) {
-                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
-                                        .formatted(targetType, linkType));
-                }
+                var targetType = info.targetType();
                 var opposite = info.opposite();
                 Multiplicity targetMultiplicity = UnconstrainedMultiplicity.INSTANCE;
                 if (opposite != null) {
@@ -185,18 +181,30 @@ public class MetamodelBuilder {
                         oppositeReferences.put(opposite, linkType);
                 }
                 if (info.containment()) {
-                        if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
-                                throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
-                                                .formatted(opposite, targetMultiplicity, linkType));
-                        }
-                        containedTypes.add(targetType);
-                        containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
+                        processContainmentInfo(linkType, info, targetMultiplicity);
                         return;
                 }
                 directedCrossReferences.put(linkType, new DirectedCrossReferenceInfo(sourceType, info.multiplicity(),
                                 targetType, targetMultiplicity));
         }
 
+        private void processContainmentInfo(PartialRelation linkType, ReferenceInfo info,
+                                                                                Multiplicity targetMultiplicity) {
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                var opposite = info.opposite();
+                if (typeHierarchyBuilder.isInvalidType(targetType)) {
+                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
+                                        .formatted(targetType, linkType));
+                }
+                if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
+                        throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
+                                        .formatted(opposite, targetMultiplicity, linkType));
+                }
+                containedTypes.add(targetType);
+                containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
+        }
+
         private static void validateOpposite(PartialRelation linkType, ReferenceInfo info, PartialRelation opposite,
                                                                                  ReferenceInfo oppositeInfo) {
                 var sourceType = info.sourceType();